123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128
import { _ISchema, _ISelection, _IDb, OnStatementExecuted, nil, QueryError, _IStatement, IValue, Parameter } from '../interfaces-private.ts';

class StackOf<T> {    readonly stack: T[] = [];    constructor(private name: string) {    }    usingValue = <ret>(value: T, act: () => ret): ret => {        this.stack.push(value);        try {            return act();        } finally {            this.stack.pop();        }    }    get current(): T {        if (!this.stack.length) {            throw new Error(`No ${this.name} available`);        }        return this.stack[this.stack.length - 1];    }
    get currentOrNil(): T | nil {        return this.stack[this.stack.length - 1];    }}

const _selectionStack = new StackOf<_ISelection>('build context');const _statementStack = new StackOf<_IStatement>('execution statement');const _tempBindings = new StackOf<Map<string, _ISelection | 'no returning'>>('binding context');const _parametersStack = new StackOf<Parameter[]>('parameter context');const _nameResolver = new StackOf<INameResolver>('name resolver');
export interface INameResolver {    /** Try to resolve a name */    resolve(name: string): IValue | nil;    /** True if is isolated... meaning that one cannot fetch values from its parent */    readonly isolated: boolean;}

interface IBuildContext {    readonly selection: _ISelection;    readonly db: _IDb;    readonly schema: _ISchema;    readonly onFinishExecution: (callback: OnStatementExecuted) => void    readonly getTempBinding: (name: string) => _ISelection | nil;    readonly setTempBinding: (name: string, boundTo: _ISelection) => void;    readonly getParameter: (nameOrPosition: string | number) => IValue | nil;}
class Context implements IBuildContext {    get selection(): _ISelection {        return _selectionStack.current;    }    get db(): _IDb {        return _selectionStack.current.db;    }    get schema(): _ISchema {        // remove the concept of selection schema ?        // (does not make much sens, if you think about it)        return _selectionStack.current.ownerSchema;    }    onFinishExecution = (callback: OnStatementExecuted) => {        _statementStack.current.onExecuted(callback);    };    getTempBinding = (name: string) => {        const ret = _tempBindings.currentOrNil?.get(name);        if (ret === 'no returning') {            throw new QueryError(`WITH query "${name}" does not have a RETURNING clause`);        }        return ret;    };    setTempBinding = (name: string, boundTo: _ISelection) => {        if (_tempBindings.current.has(name)) {            throw new QueryError(`WITH query name "${name}" specified more than once`);        }        _tempBindings.current.set(name, boundTo.isExecutionWithNoResult ? 'no returning' : boundTo);    };    getParameter = (nameOrPosition: string | number) => {        const params = _parametersStack.currentOrNil;        if (!params) {            return null;        }        if (typeof nameOrPosition === 'number') {            const ret = params[nameOrPosition]?.value;            if (!ret) {                // not ideal... (duplicated error message)                throw new QueryError(`bind message supplies ${params.length} parameters, but prepared statement "" requires ${nameOrPosition}`, '08P01');            }            return ret;        }        return params.find(p => p.value.id === nameOrPosition)?.value;    }}



const _buildCtx = new Context();export function buildCtx(): IBuildContext {    return _buildCtx;}

export const withSelection = _selectionStack.usingValue;export const withStatement = _statementStack.usingValue;export function withBindingScope<T>(act: () => T): T {    return _tempBindings.usingValue(new Map(), act);}export const withParameters = _parametersStack.usingValue;export const withNameResolver = _nameResolver.usingValue;
export function resolveName(name: string): IValue | null {    for (let i = _nameResolver.stack.length - 1; i >= 0; i--) {        const resolver = _nameResolver.stack[i];        const found = resolver.resolve(name);        if (found) {            return found;        }        if (resolver.isolated) {            return null;        }    }    return null;}