import moment from 'https://deno.land/x/momentjs@2.29.1-deno/mod.ts';import { List } from 'https://deno.land/x/immutable@4.0.0-rc.12-deno.1/mod.ts';import { IValue, NotSupported, RegClass, _IRelation, _ISchema, _ISelection, _ITable, _IType, _Transaction } from './interfaces-private.ts';import { BinaryOperator, DataTypeDef, Expr, ExprRef, ExprValueKeyword, Interval, nil, parse, QName, SelectedColumn } from 'https://deno.land/x/pgsql_ast_parser@10.5.2/mod.ts';import { ColumnNotFound, ISubscription, IType, QueryError, typeDefToStr } from './interfaces.ts';import { bufClone, bufCompare, isBuf } from './misc/buffer-deno.ts';
export interface Ctor<T> extends Function { new(...params: any[]): T; prototype: T;}
export type Optional<T> = { [key in keyof T]?: T[key] };export type SRecord<T> = Record<string, T>;
export function trimNullish<T>(value: T, depth = 5): T { if (depth < 0) return value; if (value instanceof Array) { value.forEach(x => trimNullish(x, depth - 1)) } if (typeof value !== 'object' || value instanceof Date || moment.isMoment(value) || moment.isDuration(value)) return value;
if (!value) { return value; }
for (const k of Object.keys(value)) { const val = (value as any)[k]; if (nullIsh(val)) delete (value as any)[k]; else trimNullish(val, depth - 1); } return value;}
export function watchUse<T>(rootValue: T): { checked: T; check?: () => string | null; } { if (!rootValue || typeof globalThis !== 'undefined' && (globalThis as any)?.process?.env?.['NOCHECKFULLQUERYUSAGE'] === 'true') { return { checked: rootValue }; } if (typeof rootValue !== 'object') { throw new NotSupported(); } if (Array.isArray(rootValue)) { throw new NotSupported(); } const toUse = new Map<string, any>(); function recurse(value: any, stack: List<string> = List()): any { if (!value || typeof value !== 'object') { return value; } if (Array.isArray(value)) { return value .map((x, i) => recurse(x, stack.push(`[${i}]`))); } const ret: any = {}; for (const [k, _v] of Object.entries(value)) { if (k[0] === '_') { ret[k] = _v; continue; } const nstack = stack.push('.' + k); let v = recurse(_v, nstack); const nstackKey = nstack.join(''); toUse.set(nstackKey, _v); Object.defineProperty(ret, k, { get() { toUse.delete(nstackKey); return v; }, enumerable: true, }); } return ret; }
const final = recurse(rootValue);
const check = function () { if (toUse.size) { return `The query you ran generated an AST which parts have not been read by the query planner. \This means that those parts could be ignored:
⇨ ` + [...toUse.entries()] .map(([k, v]) => k + ' (' + JSON.stringify(v) + ')') .join('\n ⇨ '); } return null; } return { checked: final, check };}
export function deepEqual<T>(a: T, b: T, strict?: boolean, depth = 10, numberDelta = 0.0001) { return deepCompare(a, b, strict, depth, numberDelta) === 0;}
export function deepCompare<T>(a: T, b: T, strict?: boolean, depth = 10, numberDelta = 0.0001): number { if (depth < 0) { throw new NotSupported('Comparing too deep entities'); }
if (a === b) { return 0; } if (!strict) { if (!a && !b) { return 0; } }
if (Array.isArray(a)) { if (!Array.isArray(b)) { return -1; } if (a.length !== b.length) { return a.length > b.length ? 1 : -1; } for (let i = 0; i < a.length; i++) { const inner = deepCompare(a[i], b[i], strict, depth - 1, numberDelta); if (inner) return inner; } return 0; }
if (Array.isArray(b)) { return 1; }
if (isBuf(a) || isBuf(b)) { if (!isBuf(a)) { return 1; } if (!isBuf(b)) { return -1; } return bufCompare(a, b); }
if (a instanceof Date || b instanceof Date || moment.isMoment(a) || moment.isMoment(b)) { const am = moment(a); const bm = moment(b); if (am.isValid() !== bm.isValid()) { return am.isValid() ? -1 : 1; } const diff = am.diff(bm, 'seconds'); if (Math.abs(diff) < 0.001) { return 0; } return diff > 0 ? 1 : -1; }
if (moment.isDuration(a) || moment.isDuration(b)) { const da = moment.duration(a); const db = moment.duration(b); if (da.isValid() !== db.isValid()) { return da.isValid() ? -1 : 1; } const diff = da.asMilliseconds() - db.asMilliseconds(); if (Math.abs(diff) < 1) { return 0; } return diff > 0 ? 1 : -1; }
const fa = Number.isFinite(<any>a); const fb = Number.isFinite(<any>b); if (fa && fb) { if (Math.abs(<any>a - <any>b) <= numberDelta) { return 0; } return a > b ? 1 : -1; } else if (fa && b) { return -1; } else if (fb && a) { return 1; }
if (typeof a !== 'object') { return 1; } if (typeof b !== 'object') { return -1; }
if (!a || !b) { return 0; }
const ak = Object.keys(a); const bk = Object.keys(b); if (strict && ak.length !== bk.length) { return ak.length > bk.length ? 1 : -1; } const set: Iterable<string> = strict ? Object.keys(a) : new Set([...Object.keys(a), ...Object.keys(b)]); for (const k of set) { const inner = deepCompare((a as any)[k], (b as any)[k], strict, depth - 1, numberDelta); if (inner) { return inner; } } return 0;}
type Json = { [key: string]: Json } | Json[] | string | number | null;export function queryJson(a: Json, b: Json) { if (!a || !b) { return (a ?? null) === (b ?? null); } if (a === b) { return true; }
if (typeof a === 'string' || typeof b === 'string') { return false; }
if (typeof a === 'number' || typeof b === 'number') { return false; }
if (Array.isArray(a)) { if (!Array.isArray(b)) { return false; } const toMatch = [...a]; for (const be of b) { for (let i = 0; i < toMatch.length; i++) { if (queryJson(toMatch[i], be)) { toMatch.splice(i, 1); break; } } if (!toMatch.length) { break; } } return !toMatch.length; }
if (Array.isArray(b)) { return false; }
if ((typeof a === 'object') !== (typeof b === 'object')) { return false; } const akeys = Object.keys(a); const bkeys = Object.keys(b); if (akeys.length > bkeys.length) { return false; } for (const ak of akeys) { if (!(ak in (b as any))) { return false; } if (!queryJson(a[ak], b[ak])) { return false; } } return true;}
export function buildLikeMatcher(likeCondition: string, caseSensitive = true) { likeCondition = likeCondition.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&'); let likeRegexString = likeCondition.replace(/\%/g, ".*").replace(/_/g, '.'); likeRegexString = "^" + likeRegexString + "$"; const reg = new RegExp(likeRegexString, caseSensitive ? '' : 'i');
return (stringToMatch: string | number) => { if (nullIsh(stringToMatch)) { return null; } if (typeof stringToMatch != "string") { stringToMatch = stringToMatch.toString(); } return reg.test(stringToMatch); }}
export function nullIsh(v: any): v is nil { return v === null || v === undefined;}
export function hasNullish(...vals: any[]): boolean { return vals.some(v => nullIsh(v));}
export function sum(v: number[]): number { return v.reduce((sum, el) => sum + el, 0);}
export function deepCloneSimple<T>(v: T): T { if (!v || typeof v !== 'object' || v instanceof Date) { return v; } if (Array.isArray(v)) { return (v as any[]).map(x => deepCloneSimple(x)) as any; } if (isBuf(v)) { return bufClone(v) as any; }
const ret: any = {}; for (const k of Object.keys(v)) { ret[k] = deepCloneSimple((v as any)[k]); } for (const k of Object.getOwnPropertySymbols(v)) { ret[k] = (v as any)[k]; } return ret;}
export function isSelectAllArgList(select: Expr[]): boolean { const [first] = select; return select.length === 1 && first.type === 'ref' && first.name === '*' && !first.table;}
export function ignore(...val: any[]): void { for (const v of val) { if (!v) { continue; } if (Array.isArray(v)) { ignore(...v); continue; } if (typeof v !== 'object') { continue; } ignore(...Object.values(v)); }}
export function combineSubs(...vals: ISubscription[]): ISubscription { return { unsubscribe: () => { vals.forEach(u => u?.unsubscribe()); }, };}
export interface ExecCtx { readonly schema: _ISchema; readonly transaction: _Transaction; readonly parametersValues?: any[];}const curCtx: ExecCtx[] = [];export function executionCtx(): ExecCtx { if (!curCtx.length) { throw new Error('No execution context available'); } return curCtx[curCtx.length - 1];}export function hasExecutionCtx(): boolean { return curCtx.length > 0;}
export function pushExecutionCtx<T>(ctx: ExecCtx, act: () => T): T { try { curCtx.push(ctx) return act(); } finally { curCtx.pop(); }}
export function indexHash(this: void, vals: (IValue | string)[]) { return vals.map(x => typeof x === 'string' ? x : x.hash).sort().join('|');}
export function randomString(length = 8, chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'): string { var result = ''; for (var i = length; i > 0; --i) result += chars[Math.floor(Math.random() * chars.length)]; return result;}
export function schemaOf(t: DataTypeDef): string | nil { if (t.kind === 'array') { return schemaOf(t.arrayOf); } return t.schema;}
export function isType(t: any): t is (_IType | IType) { return !!t?.[isType.TAG];}isType.TAG = Symbol();
export function suggestColumnName(expr: Expr | nil): string | null { if (!expr) { return null; } switch (expr.type) { case 'call': return expr.function.name; case 'ref': return expr.name; case 'keyword': return expr.keyword; case 'cast': return typeDefToStr(expr.to); } return null;}
export function findTemplate<T>(this: void, selection: _ISelection, t: _Transaction, template?: T, columns?: (keyof T)[]): Iterable<T> { let expr: Expr | nil; for (const [k, v] of Object.entries(template ?? {})) { let right: Expr; if (nullIsh(v)) { right = { type: 'unary', op: 'IS NULL', operand: { type: 'ref', name: k, }, }; } else { let value: Expr; let op: BinaryOperator = '='; switch (typeof v) { case 'number': value = Number.isInteger(v) ? { type: 'integer', value: v } : { type: 'numeric', value: v }; break; case 'string': value = { type: 'string', value: v }; break; case 'object': if (moment.isMoment(v)) { value = { type: 'string', value: v.toISOString() }; } else if (v instanceof Date) { value = { type: 'string', value: moment(v).toISOString() }; } else { op = '@>'; value = { type: 'string', value: JSON.stringify(v), }; } break; default: throw new Error(`Object type of property "${k}" not supported in template`); } right = { type: 'binary', op, left: { type: 'ref', name: k, }, right: value }; } expr = !expr ? right : { type: 'binary', op: 'AND', left: expr, right, }; }
let ret = selection .filter(expr); if (columns) { ret = ret.select(columns.map<SelectedColumn>(x => ({ expr: { type: 'ref', name: x as string }, }))); } return ret.enumerate(t);}
function ver(v: string) { if (!v || !/^\d+(\.\d+)+$/.test(v)) { throw new Error('Invalid semver ' + v) } return v.split(/\./g).map(x => parseInt(x, 10));}export function compareVersions(_a: string, _b: string): number { const a = ver(_a); const b = ver(_b); const m = Math.max(a.length, b.length); for (let i = 0; i < m; i++) { const d = (b[i] || 0) - (a[i] || 0); if (d !== 0) { return d; } } return 0;}
export function intervalToSec(v: Interval) { return (v.milliseconds ?? 0) / 1000 + (v.seconds ?? 0) + (v.minutes ?? 0) * 60 + (v.hours ?? 0) * 3600 + (v.days ?? 0) * 3600 * 24 + (v.months ?? 0) * 3600 * 24 * 30 + (v.years ?? 0) * 3600 * 24 * 30 * 12;}
export function parseRegClass(_reg: RegClass): QName | number { let reg = _reg; if (typeof reg === 'string' && /^\d+$/.test(reg)) { reg = parseInt(reg); } if (typeof reg === 'number') { return reg; } try { const ret = parse(reg, 'qualified_name' as any) as QName; return ret; } catch (e) { return { name: reg }; }}
const timeReg = /^(\d+):(\d+)(:(\d+))?(\.\d+)?$/;export function parseTime(str: string): moment.Moment { const [_, a, b, __, c, d] = timeReg.exec(str) ?? []; if (!_) { throw new QueryError(`Invalid time format: ` + str); } const ms = d ? parseFloat(d) * 1000 : undefined; let ret: moment.Moment; if (c) { ret = moment.utc({ h: parseInt(a, 10), m: parseInt(b, 10), s: parseInt(c, 10), ms, }); } else { if (d) { ret = moment.utc({ m: parseInt(a, 10), s: parseInt(b, 10), ms, }); } else { ret = moment.utc({ h: parseInt(a, 10), m: parseInt(b, 10), ms, }); } } if (!ret.isValid()) { throw new QueryError(`Invalid time format: ` + str); } return ret;}
export function colByName<T>(refs: Map<string, T>, ref: string | ExprRef, nullIfNotFound: boolean | nil): T | nil { const nm = typeof ref === 'string' ? ref : !ref.table ? ref.name : null; const got = nm ? refs.get(nm) : null; if (!got && !nullIfNotFound) { throw new ColumnNotFound(colToStr(ref)); } return got;}
export function colToStr(col: string | ExprRef) { if (typeof col === 'string') { return col; } if (!col.table) { return col.name; } return col.table.name + '.' + col.name;}
export function qnameToStr(col: string | QName) { if (typeof col === 'string') { return col; } if (!col.schema) { return col.name; } return col.schema + '.' + col.name;}
export function asSingleName(col: string | ExprRef): string | nil { if (typeof col === 'string') { return col; } if (col.table) { return null; } return col.name;}
export function asSingleQName(col: string | QName, allowedSchema?: string): string | nil { if (typeof col === 'string') { return col; } if (col.schema && col.schema !== allowedSchema) { return null; } return col.name;}
export function errorMessage(error: unknown): string { if (typeof error === 'string') { return error; } if (typeof error !== 'object') { return 'Unkown error message'; } return (error as any)?.message;}
export function it<T>(iterable: Iterable<T>): IteratorHelper<T> { return iterable instanceof IteratorHelper ? iterable as any : new IteratorHelper(() => iterable);}
export class IteratorHelper<T> implements Iterable<T> { constructor(private underlying: () => Iterable<T>) { }
[Symbol.iterator]() { return this.underlying()[Symbol.iterator](); }
flatten(): T extends Iterable<infer X> ? IteratorHelper<X> : never { const that = this; function* wrap() { for (const v of that.underlying() as any ?? []) { for (const x of v) { yield x; } } } return new IteratorHelper(wrap) as any; }
reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number) => U, initialValue: U): U { let acc = initialValue; let i = 0; for (const v of this.underlying()) { acc = callbackfn(acc, v, i); i++; } return acc; }}
export function fromEntries<K, V>(iterable: [K, V][]): Map<K, V> { const ret = new Map<K, V>(); for (const [k, v] of iterable) { ret.set(k, v); } return ret;}
export function notNil<T>(value: (T | nil)[] | nil): Exclude<T, null>[] { return (value ?? []).filter((x) => !nullIsh(x)) as any[];}
export function modifyIfNecessary<T>(values: T[], mapper: (input: T) => T | nil): T[] { let ret: T[] | undefined; for (let i = 0; i < values.length; i++) { const mapped = mapper(values[i]); if (nullIsh(mapped)) { continue; } if (!ret) { ret = [...values]; } ret[i] = mapped; } return ret ?? values;}