fastify-auto-sqlapi 0.0.1

package/dist/lib/cli/schema-codegen.js

@@ -0,0 +1,100 @@
+import { toCamelCase, toSchemaName } from '../naming.js';
+export function convertColType(udtName, columnInfo) {
+    const hasDefault = columnInfo.column_default;
+    const isNullable = columnInfo.is_nullable === 'YES';
+    const wrap = (t) => {
+        return hasDefault || isNullable ? `Type.Optional(${t})` : t;
+    };
+    switch (udtName) {
+        case 'uuid':
+            return wrap("Type.String({format: 'uuid'})");
+        case 'bool':
+            return wrap('Type.Boolean()');
+        case 'float4':
+        case 'float8':
+        case 'numeric':
+            return wrap('Type.Number()');
+        case 'int2':
+        case 'int4':
+        case 'int8':
+            return wrap('Type.Integer()');
+        case 'varchar':
+        case 'text':
+        case 'char':
+        case 'bpchar':
+            return wrap('Type.String()');
+        case 'timestamptz':
+        case 'timestamp':
+            return wrap('Type.String()');
+        case 'date':
+            return wrap("Type.String({format: 'date'})");
+        case 'time':
+            return wrap('Type.String()');
+        case 'jsonb':
+        case 'json':
+            return wrap('Type.Any()');
+        case '_varchar':
+        case '_text':
+            return wrap('Type.Array(Type.String())');
+        case '_int2':
+        case '_int4':
+        case '_int8':
+            return wrap('Type.Array(Type.Integer())');
+        case '_float4':
+        case '_float8':
+            return wrap('Type.Array(Type.Number())');
+        default:
+            if (udtName.substring(0, 3) === 'int') {
+                return wrap('Type.Integer()');
+            }
+            return wrap('Type.String()');
+    }
+}
+export function buildTableMap(rows) {
+    return rows.reduce((acc, row) => {
+        const schemaName = toSchemaName(row.table_name);
+        if (!acc[schemaName]) {
+            acc[schemaName] = {
+                name: row.table_name,
+                fields: {},
+            };
+        }
+        acc[schemaName].fields[toCamelCase(row.column_name)] = convertColType(row.udt_name, row);
+        return acc;
+    }, {});
+}
+export function generateSchemaFile(schemaName, tableName, fields) {
+    const fieldsStr = JSON.stringify(fields, null, 2).replace(/"(.*?)"\s*:\s*"Type(.*?)"/g, '$1: Type$2');
+    return `// Auto-generated by fastify-auto-sqlapi. Do not edit.
+import { Type, toUnderscore } from "fastify-auto-sqlapi";
+import type { Static } from "fastify-auto-sqlapi";
+
+const _Schema = ${fieldsStr};
+
+const validation = Type.Object(_Schema, { $id: "${schemaName}" });
+const partialValidation = Type.Object(
+  Object.fromEntries(
+    Object.entries(_Schema).map(([k, v]) => [
+      k,
+      (validation.required as string[] | undefined)?.includes(k) ? Type.Optional(v) : v,
+    ])
+  ),
+  { additionalProperties: false, $id: "Partial${schemaName}" }
+);
+
+export const Schema = {
+  col: (f: keyof typeof _Schema) => toUnderscore(f),
+  fields: _Schema,
+  validation,
+  tableName: "${tableName}",
+  partialValidation,
+};
+export const ${schemaName} = Schema;
+export type TypeSchema = Static<typeof Schema.validation>;
+export type Type${schemaName} = TypeSchema;
+export default async function (fastify: any) {
+  fastify.addSchema(partialValidation);
+  fastify.addSchema(validation);
+}
+`;
+}

package/dist/lib/cli/tables-codegen.d.ts

@@ -0,0 +1,18 @@
+export interface ParsedSchema {
+    schemaName: string;
+    tableName: string;
+    fields: string[];
+    fieldTypes: Record<string, string>;
+}
+export interface DetectedRelation {
+    parentSchemaName: string;
+    parentField: string;
+    childSchemaName: string;
+    childField: string;
+}
+export declare function parseSchemaFile(content: string): ParsedSchema | null;
+export declare function detectRelations(schemas: ParsedSchema[]): DetectedRelation[];
+export declare function generateSingleTableFile(schema: ParsedSchema, allSchemas: ParsedSchema[]): string;
+export declare function generateDbTablesIndex(schemas: ParsedSchema[]): string;
+export declare function generateTablesFile(schemas: ParsedSchema[]): string;
+//# sourceMappingURL=tables-codegen.d.ts.map

package/dist/lib/cli/tables-codegen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tables-codegen.d.ts","sourceRoot":"","sources":["../../../src/lib/cli/tables-codegen.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,YAAY;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,gBAAgB;IAC/B,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;CACpB;AAID,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CA2BpE;AAgBD,wBAAgB,eAAe,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,gBAAgB,EAAE,CAwB3E;AAID,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,GAAG,MAAM,CAiGhG;AAID,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,MAAM,CAqBrE;AAID,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,MAAM,CAoFlE"}

package/dist/lib/cli/tables-codegen.js

@@ -0,0 +1,249 @@
+import { toUnderscore } from '../naming.js';
+// ─── Parsing ─────────────────────────────────────────────────
+export function parseSchemaFile(content) {
+    const tableNameMatch = content.match(/tableName:\s*"([^"]+)"/);
+    if (!tableNameMatch)
+        return null;
+    const exportMatch = content.match(/export const (Schema\w+)\s*=\s*Schema/);
+    if (!exportMatch)
+        return null;
+    const schemaBlockMatch = content.match(/const _Schema\s*=\s*\{([\s\S]*?)};/);
+    if (!schemaBlockMatch)
+        return null;
+    const fields = [];
+    const fieldTypes = {};
+    const fieldRegex = /^\s+(\w+):\s+(Type\..+)$/gm;
+    let match;
+    while ((match = fieldRegex.exec(schemaBlockMatch[1])) !== null) {
+        fields.push(match[1]);
+        fieldTypes[match[1]] = match[2].replace(/,\s*$/, '');
+    }
+    if (fields.length === 0)
+        return null;
+    return {
+        schemaName: exportMatch[1],
+        tableName: tableNameMatch[1],
+        fields,
+        fieldTypes,
+    };
+}
+// ─── Detection ───────────────────────────────────────────────
+function detectPrimaryKey(schema) {
+    if (schema.fields.includes('id')) {
+        return { pk: 'id', autoIncrement: schema.fieldTypes['id']?.includes('Optional') ?? false };
+    }
+    for (const field of schema.fields) {
+        if (schema.fieldTypes[field]?.includes('Integer')) {
+            return { pk: field, autoIncrement: schema.fieldTypes[field].includes('Optional') };
+        }
+    }
+    return { pk: schema.fields[0], autoIncrement: false };
+}
+export function detectRelations(schemas) {
+    const tableBySnakeName = new Map();
+    for (const schema of schemas) {
+        tableBySnakeName.set(schema.tableName, schema);
+    }
+    const relations = [];
+    for (const schema of schemas) {
+        for (const field of schema.fields) {
+            if (!field.endsWith('Id') || field === 'id')
+                continue;
+            const parentTableName = toUnderscore(field.slice(0, -2));
+            const parent = tableBySnakeName.get(parentTableName);
+            if (parent) {
+                const { pk } = detectPrimaryKey(parent);
+                relations.push({
+                    parentSchemaName: parent.schemaName,
+                    parentField: pk,
+                    childSchemaName: schema.schemaName,
+                    childField: field,
+                });
+            }
+        }
+    }
+    return relations;
+}
+// ─── Single Table File Generation ────────────────────────────
+export function generateSingleTableFile(schema, allSchemas) {
+    const relations = detectRelations(allSchemas);
+    const relsByParent = new Map();
+    const relsByChild = new Map();
+    for (const rel of relations) {
+        const arr = relsByParent.get(rel.parentSchemaName) || [];
+        arr.push(rel);
+        relsByParent.set(rel.parentSchemaName, arr);
+        const childArr = relsByChild.get(rel.childSchemaName) || [];
+        childArr.push(rel);
+        relsByChild.set(rel.childSchemaName, childArr);
+    }
+    const { pk, autoIncrement } = detectPrimaryKey(schema);
+    const tableVarName = 'Table' + schema.schemaName.replace(/^Schema/, '');
+    const parentRels = relsByParent.get(schema.schemaName) || [];
+    const childRels = relsByChild.get(schema.schemaName) || [];
+    // Collect related schema names for commented imports
+    const relatedSchemas = new Set();
+    for (const rel of parentRels) {
+        if (rel.childSchemaName !== schema.schemaName)
+            relatedSchemas.add(rel.childSchemaName);
+        if (rel.parentSchemaName !== schema.schemaName)
+            relatedSchemas.add(rel.parentSchemaName);
+    }
+    for (const rel of childRels) {
+        if (rel.parentSchemaName !== schema.schemaName)
+            relatedSchemas.add(rel.parentSchemaName);
+        if (rel.childSchemaName !== schema.schemaName)
+            relatedSchemas.add(rel.childSchemaName);
+    }
+    const lines = [];
+    // Imports
+    lines.push(`import {defineTable, exportTableInfo, Type} from 'fastify-auto-sqlapi';`);
+    lines.push(`import {${schema.schemaName} as Schema} from '../schemas/${schema.schemaName}';`);
+    // Commented imports for related schemas
+    for (const relSchema of relatedSchemas) {
+        lines.push(`// import {${relSchema}} from '../schemas/${relSchema}';`);
+    }
+    lines.push(``);
+    // Extra filters placeholder
+    lines.push(`// const extraFiltersValidation = Type.Object({`);
+    lines.push(`//   q: Type.String(),`);
+    lines.push(`// });`);
+    // Table definition
+    lines.push(``);
+    lines.push(`// Fields: ${schema.fields.join(', ')}`);
+    lines.push(`export const ${tableVarName} = defineTable({`);
+    lines.push(`  primary: '${pk}',`);
+    lines.push(`  ...exportTableInfo(Schema),`);
+    // Commented example with extraFilters + extendedCondition
+    lines.push(`  // ...exportTableInfo(`);
+    lines.push(`  //   Schema,`);
+    lines.push(`  //   extraFiltersValidation,`);
+    lines.push(`  //   (condition, filters) => {`);
+    lines.push(`  //     if (filters.q) condition.isILike(Schema.col('${schema.fields.includes('name') ? 'name' : schema.fields[0]}'), \`%\${filters.q}%\`);`);
+    lines.push(`  //   }`);
+    lines.push(`  // ),`);
+    lines.push(`  defaultOrder: '${pk}',`);
+    if (autoIncrement) {
+        lines.push(`  excludeFromCreation: ['${pk}'],`);
+    }
+    else {
+        lines.push(`  // excludeFromCreation: [],`);
+    }
+    if (parentRels.length > 0) {
+        lines.push(`  // allowedReadJoins: [`);
+        for (const rel of parentRels) {
+            lines.push(`  //   buildRelation(${rel.parentSchemaName}, '${rel.parentField}', ${rel.childSchemaName}, '${rel.childField}'),`);
+        }
+        lines.push(`  // ],`);
+    }
+    else {
+        lines.push(`  // allowedReadJoins: [],`);
+    }
+    lines.push(`  // upsertMap: buildUpsertRules(buildUpsertRule(Schema, ['${pk}'])),`);
+    lines.push(`  // beforeInsert: async (db, req, record) => {},`);
+    lines.push(`  // beforeUpdate: async (db, req, fields) => {},`);
+    if (childRels.length > 0) {
+        const rel = childRels[0];
+        lines.push(`  // tenantScope: { column: 'tenant_col', through: { schema: ${rel.parentSchemaName}, localField: '${rel.childField}', foreignField: '${rel.parentField}' } },`);
+    }
+    else {
+        lines.push(`  // tenantScope: { column: 'tenant_col' },`);
+    }
+    lines.push(`});`);
+    lines.push(``);
+    return lines.join('\n');
+}
+// ─── DbTables Index Generation ──────────────────────────────
+export function generateDbTablesIndex(schemas) {
+    const lines = [];
+    lines.push(`import type { DbTables } from 'fastify-auto-sqlapi';`);
+    lines.push(``);
+    for (const schema of schemas) {
+        const tableVarName = 'Table' + schema.schemaName.replace(/^Schema/, '');
+        lines.push(`import {${tableVarName}} from './${tableVarName}';`);
+    }
+    lines.push(``);
+    lines.push(`export const dbTables: DbTables = {`);
+    for (const schema of schemas) {
+        const tableVarName = 'Table' + schema.schemaName.replace(/^Schema/, '');
+        lines.push(`  ${schema.tableName}: ${tableVarName},`);
+    }
+    lines.push(`};`);
+    lines.push(``);
+    return lines.join('\n');
+}
+// ─── Code Generation (legacy) ───────────────────────────────
+export function generateTablesFile(schemas) {
+    const relations = detectRelations(schemas);
+    const relsByParent = new Map();
+    const relsByChild = new Map();
+    for (const rel of relations) {
+        const arr = relsByParent.get(rel.parentSchemaName) || [];
+        arr.push(rel);
+        relsByParent.set(rel.parentSchemaName, arr);
+        const childArr = relsByChild.get(rel.childSchemaName) || [];
+        childArr.push(rel);
+        relsByChild.set(rel.childSchemaName, childArr);
+    }
+    const lines = [];
+    // Imports
+    lines.push(`import {defineTable, exportTableInfo, Type} from 'fastify-auto-sqlapi';`);
+    lines.push(`import type { DbTables } from 'fastify-auto-sqlapi';`);
+    lines.push(``);
+    // Schema imports
+    for (const schema of schemas) {
+        lines.push(`import {${schema.schemaName}} from './${schema.schemaName}';`);
+    }
+    // Table definitions
+    for (const schema of schemas) {
+        const { pk, autoIncrement } = detectPrimaryKey(schema);
+        const tableVarName = 'Table' + schema.schemaName.replace(/^Schema/, '');
+        const parentRels = relsByParent.get(schema.schemaName) || [];
+        lines.push(``);
+        lines.push(`// ─── ${schema.tableName} ──────────────────────────────`);
+        lines.push(`// Fields: ${schema.fields.join(', ')}`);
+        lines.push(`const ${tableVarName} = defineTable({`);
+        lines.push(`  primary: '${pk}',`);
+        lines.push(`  ...exportTableInfo(${schema.schemaName}),`);
+        lines.push(`  defaultOrder: '${pk}',`);
+        if (autoIncrement) {
+            lines.push(`  excludeFromCreation: ['${pk}'],`);
+        }
+        else {
+            lines.push(`  // excludeFromCreation: [],`);
+        }
+        if (parentRels.length > 0) {
+            lines.push(`  // allowedReadJoins: [`);
+            for (const rel of parentRels) {
+                lines.push(`  //   buildRelation(${rel.parentSchemaName}, '${rel.parentField}', ${rel.childSchemaName}, '${rel.childField}'),`);
+            }
+            lines.push(`  // ],`);
+        }
+        else {
+            lines.push(`  // allowedReadJoins: [],`);
+        }
+        lines.push(`  // upsertMap: buildUpsertRules(buildUpsertRule(${schema.schemaName}, ['${pk}'])),`);
+        lines.push(`  // beforeInsert: async (db, req, record) => {},`);
+        lines.push(`  // beforeUpdate: async (db, req, fields) => {},`);
+        const childRels = relsByChild.get(schema.schemaName) || [];
+        if (childRels.length > 0) {
+            const rel = childRels[0];
+            lines.push(`  // tenantScope: { column: 'tenant_col', through: { schema: ${rel.parentSchemaName}, localField: '${rel.childField}', foreignField: '${rel.parentField}' } },`);
+        }
+        else {
+            lines.push(`  // tenantScope: { column: 'tenant_col' },`);
+        }
+        lines.push(`});`);
+    }
+    // DbTables export
+    lines.push(``);
+    lines.push(`// ─── DbTables ──────────────────────────────────────`);
+    lines.push(`export const dbTables: DbTables = {`);
+    for (const schema of schemas) {
+        const tableVarName = 'Table' + schema.schemaName.replace(/^Schema/, '');
+        lines.push(`  ${schema.tableName}: ${tableVarName},`);
+    }
+    lines.push(`};`);
+    lines.push(``);
+    return lines.join('\n');
+}

package/dist/lib/condition-methods.d.ts

@@ -0,0 +1,11 @@
+export declare const SINGLE_VALUE_METHODS: readonly ["isEqual", "isNotEqual", "isGreater", "isNotGreater", "isGreaterOrEqual", "isNotGreaterOrEqual", "isLess", "isNotLess", "isLessOrEqual", "isNotLessOrEqual", "isLike", "isNotLike", "isILike", "isNotILike"];
+export declare const BETWEEN_METHODS: readonly ["isBetween", "isNotBetween"];
+export declare const IN_METHODS: readonly ["isIn", "isNotIn"];
+export declare const NULL_METHODS: readonly ["isNull", "isNotNull"];
+export declare const ALLOWED_METHODS: readonly ["isEqual", "isNotEqual", "isGreater", "isNotGreater", "isGreaterOrEqual", "isNotGreaterOrEqual", "isLess", "isNotLess", "isLessOrEqual", "isNotLessOrEqual", "isLike", "isNotLike", "isILike", "isNotILike", "isBetween", "isNotBetween", "isIn", "isNotIn", "isNull", "isNotNull"];
+export declare const SINGLE_VALUE_SET: Set<string>;
+export declare const BETWEEN_SET: Set<string>;
+export declare const IN_SET: Set<string>;
+export declare const NULL_SET: Set<string>;
+export declare const ALLOWED_SET: Set<string>;
+//# sourceMappingURL=condition-methods.d.ts.map

package/dist/lib/condition-methods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"condition-methods.d.ts","sourceRoot":"","sources":["../../src/lib/condition-methods.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,oBAAoB,wNAKvB,CAAC;AAEX,eAAO,MAAM,eAAe,wCAAyC,CAAC;AACtE,eAAO,MAAM,UAAU,8BAA+B,CAAC;AACvD,eAAO,MAAM,YAAY,kCAAmC,CAAC;AAE7D,eAAO,MAAM,eAAe,+RAElB,CAAC;AAGX,eAAO,MAAM,gBAAgB,aAAwC,CAAC;AACtE,eAAO,MAAM,WAAW,aAAmC,CAAC;AAC5D,eAAO,MAAM,MAAM,aAA8B,CAAC;AAClD,eAAO,MAAM,QAAQ,aAAgC,CAAC;AACtD,eAAO,MAAM,WAAW,aAAmC,CAAC"}

package/dist/lib/condition-methods.js

@@ -0,0 +1,20 @@
+// Allowed ConditionBuilder methods for the `conditions` search API.
+// Single source of truth for both schema validation (Swagger) and runtime whitelist.
+export const SINGLE_VALUE_METHODS = [
+    'isEqual', 'isNotEqual',
+    'isGreater', 'isNotGreater', 'isGreaterOrEqual', 'isNotGreaterOrEqual',
+    'isLess', 'isNotLess', 'isLessOrEqual', 'isNotLessOrEqual',
+    'isLike', 'isNotLike', 'isILike', 'isNotILike',
+];
+export const BETWEEN_METHODS = ['isBetween', 'isNotBetween'];
+export const IN_METHODS = ['isIn', 'isNotIn'];
+export const NULL_METHODS = ['isNull', 'isNotNull'];
+export const ALLOWED_METHODS = [
+    ...SINGLE_VALUE_METHODS, ...BETWEEN_METHODS, ...IN_METHODS, ...NULL_METHODS,
+];
+// Runtime Sets for fast lookup
+export const SINGLE_VALUE_SET = new Set(SINGLE_VALUE_METHODS);
+export const BETWEEN_SET = new Set(BETWEEN_METHODS);
+export const IN_SET = new Set(IN_METHODS);
+export const NULL_SET = new Set(NULL_METHODS);
+export const ALLOWED_SET = new Set(ALLOWED_METHODS);

package/dist/lib/db.d.ts

@@ -0,0 +1,28 @@
+import { Expression } from 'node-condition-builder';
+import type { ConditionBuilder } from 'node-condition-builder';
+import type { Queryable, SqlResult, DbRecord, SelectOptions } from '../types.js';
+import type { SqlDialect } from './dialect.js';
+/** @deprecated Use db.qi() instead */
+export declare const escapeIdent: (f: string) => string;
+export declare class QueryClient {
+    #private;
+    private client;
+    private dialect;
+    private debug;
+    constructor(client: Queryable, dialect?: SqlDialect);
+    get qi(): (id: string) => string;
+    get ph(): (i: number) => string;
+    get dialectName(): string;
+    setDebug(mode: boolean): void;
+    expression(value: string): Expression;
+    query<T = Record<string, unknown>>(text: string, values?: unknown[]): Promise<SqlResult<T>>;
+    insert(table: string, record: DbRecord, pkCol: string | string[]): Promise<Record<string, unknown>>;
+    insertOrUpdate(table: string, record: DbRecord, conflictKeys: string[], pkCol: string | string[]): Promise<Record<string, unknown>>;
+    bulkInsert(table: string, records: DbRecord[], pkCol: string | string[], chunkSize?: number): Promise<Record<string, unknown>[]>;
+    bulkInsertOrUpdate(table: string, records: DbRecord[], conflictKeys: string[], pkCol: string | string[], chunkSize?: number): Promise<Record<string, unknown>[]>;
+    update(table: string, record: DbRecord, where: DbRecord, extraCondition?: ConditionBuilder): Promise<number>;
+    delete(table: string, where: DbRecord): Promise<number>;
+    select<T = Record<string, unknown>>({ tableName, columns, where, values, limit, orderBy, joins, distinct, }: SelectOptions): Promise<T[]>;
+}
+export declare function createQueryClient(pool: Queryable, dialectName?: string): QueryClient;
+//# sourceMappingURL=db.d.ts.map

package/dist/lib/db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../src/lib/db.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAK/C,sCAAsC;AACtC,eAAO,MAAM,WAAW,GAAI,GAAG,MAAM,WAA0B,CAAC;AAEhE,qBAAa,WAAW;;IACtB,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,OAAO,CAAa;IAC5B,OAAO,CAAC,KAAK,CAAS;gBAEV,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,UAAU;IAKnD,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM,CAE/B;IAED,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAE9B;IAED,IAAI,WAAW,IAAI,MAAM,CAExB;IAED,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IAI7B,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU;IAIrC,KAAK,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,OAAO,EAAE,GACjB,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IA6FlB,MAAM,CACV,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,QAAQ,EAChB,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GACvB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAoB7B,cAAc,CAClB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,QAAQ,EAChB,YAAY,EAAE,MAAM,EAAE,EACtB,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GACvB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAuB7B,UAAU,CACd,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,QAAQ,EAAE,EACnB,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,EACxB,SAAS,SAAqB,GAC7B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IA2B/B,kBAAkB,CACtB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,QAAQ,EAAE,EACnB,YAAY,EAAE,MAAM,EAAE,EACtB,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,EACxB,SAAS,SAAqB,GAC7B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IA+B/B,MAAM,CACV,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,QAAQ,EAChB,KAAK,EAAE,QAAQ,EACf,cAAc,CAAC,EAAE,gBAAgB,GAChC,OAAO,CAAC,MAAM,CAAC;IAuBZ,MAAM,CACV,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,QAAQ,GACd,OAAO,CAAC,MAAM,CAAC;IAYZ,MAAM,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EACxC,SAAS,EACT,OAAa,EACb,KAAK,EACL,MAAM,EACN,KAAY,EACZ,OAAY,EACZ,KAAU,EACV,QAAgB,GACjB,EAAE,aAAa,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;CAchC;AAED,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,SAAS,EACf,WAAW,CAAC,EAAE,MAAM,GACnB,WAAW,CAGb"}

package/dist/lib/db.js

@@ -0,0 +1,224 @@
+import { Expression } from 'node-condition-builder';
+import { getDialect } from './dialect.js';
+const DEFAULT_CHUNK_SIZE = 500;
+/** @deprecated Use db.qi() instead */
+export const escapeIdent = (f) => f.replace(/"/g, '""');
+export class QueryClient {
+    client;
+    dialect;
+    debug = false;
+    constructor(client, dialect) {
+        this.client = client;
+        this.dialect = dialect ?? getDialect('postgres');
+    }
+    get qi() {
+        return this.dialect.qi;
+    }
+    get ph() {
+        return this.dialect.ph;
+    }
+    get dialectName() {
+        return this.dialect.name;
+    }
+    setDebug(mode) {
+        this.debug = mode;
+    }
+    expression(value) {
+        return new Expression(value);
+    }
+    query(text, values) {
+        if (this.debug) {
+            console.log('SQL:', text.replace(/\s+/g, ' ').trim());
+            console.log('PARAMS:', values || []);
+        }
+        return this.client.query(text, values);
+    }
+    // Quote a list of fields
+    #q(fields) {
+        return fields.map((f) => this.dialect.qi(f)).join(', ');
+    }
+    // Appends record fields/values to a shared values array, auto-indexing placeholders
+    #params(record, values) {
+        const fields = [];
+        const placeholders = [];
+        for (const [field, val] of Object.entries(record)) {
+            fields.push(field);
+            if (val instanceof Expression) {
+                placeholders.push(val.value);
+            }
+            else {
+                values.push(val);
+                placeholders.push(this.dialect.ph(values.length));
+            }
+        }
+        return { fields, placeholders };
+    }
+    // Builds multi-row VALUES string for bulk operations
+    #bulkValues(fields, records) {
+        const values = [];
+        const rowPlaceholders = [];
+        for (const record of records) {
+            const cols = [];
+            for (const field of fields) {
+                const val = record[field];
+                if (val instanceof Expression) {
+                    cols.push(val.value);
+                }
+                else {
+                    values.push(val);
+                    cols.push(this.dialect.ph(values.length));
+                }
+            }
+            rowPlaceholders.push(`(${cols.join(', ')})`);
+        }
+        return { values, rows: rowPlaceholders.join(', ') };
+    }
+    // Build the update SET for upsert: dialect-specific
+    #upsertUpdateSet(fields, conflictKeys) {
+        const updateCols = fields.filter((f) => !conflictKeys.includes(f));
+        if (!updateCols.length)
+            return '';
+        if (this.dialect.name === 'postgres') {
+            return updateCols
+                .map((f) => `${this.dialect.qi(f)} = EXCLUDED.${this.dialect.qi(f)}`)
+                .join(', ');
+        }
+        // MySQL/MariaDB: VALUES(col) syntax
+        return updateCols
+            .map((f) => `${this.dialect.qi(f)} = VALUES(${this.dialect.qi(f)})`)
+            .join(', ');
+    }
+    #quotedPkCols(pkCol) {
+        const cols = Array.isArray(pkCol) ? pkCol : [pkCol];
+        return cols.map((c) => this.dialect.qi(c)).join(', ');
+    }
+    #mysqlPkResult(pkCol, record, insertId) {
+        const cols = Array.isArray(pkCol) ? pkCol : [pkCol];
+        const result = {};
+        for (const col of cols) {
+            if (col in record && record[col] != null) {
+                result[col] = record[col];
+            }
+        }
+        if (Object.keys(result).length > 0)
+            return result;
+        if (!Array.isArray(pkCol))
+            return { [pkCol]: insertId };
+        return result;
+    }
+    async insert(table, record, pkCol) {
+        const values = [];
+        const { fields, placeholders } = this.#params(record, values);
+        if (!fields.length)
+            throw new Error('Cannot execute empty insert');
+        const returning = this.dialect.returningPk(this.#quotedPkCols(pkCol));
+        const result = await this.query(`INSERT INTO ${this.dialect.qi(table)} (${this.#q(fields)})
+       VALUES (${placeholders.join(', ')})${returning}`, values);
+        if (this.dialect.supportsReturning) {
+            return result.rows[0];
+        }
+        return this.#mysqlPkResult(pkCol, record, result.insertId);
+    }
+    async insertOrUpdate(table, record, conflictKeys, pkCol) {
+        const values = [];
+        const { fields, placeholders } = this.#params(record, values);
+        if (!fields.length)
+            throw new Error('Cannot execute empty insert');
+        const updateSet = this.#upsertUpdateSet(fields, conflictKeys);
+        const upsertClause = this.dialect.upsertSql(this.#q(conflictKeys), updateSet);
+        const returning = this.dialect.returningPk(this.#quotedPkCols(pkCol));
+        const result = await this.query(`INSERT INTO ${this.dialect.qi(table)} (${this.#q(fields)})
+       VALUES (${placeholders.join(', ')})
+       ${upsertClause}${returning}`, values);
+        if (this.dialect.supportsReturning) {
+            return result.rows[0];
+        }
+        return this.#mysqlPkResult(pkCol, record, result.insertId);
+    }
+    async bulkInsert(table, records, pkCol, chunkSize = DEFAULT_CHUNK_SIZE) {
+        if (!records.length)
+            return [];
+        const fields = Object.keys(records[0]);
+        const results = [];
+        const returning = this.dialect.returningPk(this.#quotedPkCols(pkCol));
+        for (let i = 0; i < records.length; i += chunkSize) {
+            const chunk = records.slice(i, i + chunkSize);
+            const { values, rows } = this.#bulkValues(fields, chunk);
+            const result = await this.query(`INSERT INTO ${this.dialect.qi(table)} (${this.#q(fields)}) VALUES ${rows}${returning}`, values);
+            if (this.dialect.supportsReturning) {
+                results.push(...result.rows);
+            }
+            else {
+                for (const rec of chunk) {
+                    results.push(this.#mysqlPkResult(pkCol, rec, result.insertId));
+                }
+            }
+        }
+        return results;
+    }
+    async bulkInsertOrUpdate(table, records, conflictKeys, pkCol, chunkSize = DEFAULT_CHUNK_SIZE) {
+        if (!records.length)
+            return [];
+        const fields = Object.keys(records[0]);
+        const updateSet = this.#upsertUpdateSet(fields, conflictKeys);
+        const upsertClause = this.dialect.upsertSql(this.#q(conflictKeys), updateSet);
+        const returning = this.dialect.returningPk(this.#quotedPkCols(pkCol));
+        const results = [];
+        for (let i = 0; i < records.length; i += chunkSize) {
+            const chunk = records.slice(i, i + chunkSize);
+            const { values, rows } = this.#bulkValues(fields, chunk);
+            const result = await this.query(`INSERT INTO ${this.dialect.qi(table)} (${this.#q(fields)})
+         VALUES ${rows}
+         ${upsertClause}${returning}`, values);
+            if (this.dialect.supportsReturning) {
+                results.push(...result.rows);
+            }
+            else {
+                for (const rec of chunk) {
+                    results.push(this.#mysqlPkResult(pkCol, rec, result.insertId));
+                }
+            }
+        }
+        return results;
+    }
+    async update(table, record, where, extraCondition) {
+        const values = [];
+        const { fields: setF, placeholders: setP } = this.#params(record, values);
+        const { fields: whereF, placeholders: whereP } = this.#params(where, values);
+        let extraWhere = '';
+        if (extraCondition) {
+            extraWhere = ` AND ${extraCondition.build(values.length + 1, this.dialect.ph)}`;
+            values.push(...extraCondition.getValues());
+        }
+        const result = await this.query(`UPDATE ${this.dialect.qi(table)}
+       SET ${setF.map((f, i) => `${this.dialect.qi(f)} = ${setP[i]}`).join(', ')}
+       WHERE ${whereF.map((f, i) => `${this.dialect.qi(f)} = ${whereP[i]}`).join(' AND ')}${extraWhere}`, values);
+        return result.affectedRows;
+    }
+    async delete(table, where) {
+        const values = [];
+        const { fields, placeholders } = this.#params(where, values);
+        const result = await this.query(`DELETE FROM ${this.dialect.qi(table)}
+       WHERE ${fields.map((f, i) => `${this.dialect.qi(f)} = ${placeholders[i]}`).join(' AND ')}`, values);
+        return result.affectedRows;
+    }
+    async select({ tableName, columns = '*', where, values, limit = null, orderBy = '', joins = [], distinct = false, }) {
+        const cols = columns === '*' ? `${this.dialect.qi(tableName)}.*` : columns;
+        const parts = [
+            `SELECT${distinct ? ' DISTINCT' : ''} ${cols}`,
+            `FROM ${this.dialect.qi(tableName)}`,
+            ...joins,
+            `WHERE ${where}`,
+        ];
+        if (orderBy)
+            parts.push(`ORDER BY ${orderBy}`);
+        if (limit !== null)
+            parts.push(`LIMIT ${limit}`);
+        const result = await this.query(parts.join('\n'), values);
+        return result.rows;
+    }
+}
+export function createQueryClient(pool, dialectName) {
+    const dialect = getDialect((dialectName || 'postgres'));
+    return new QueryClient(pool, dialect);
+}