fastify-auto-sqlapi 0.0.1

package/dist/lib/schema/search.js

@@ -0,0 +1,99 @@
+import { Type } from '@sinclair/typebox';
+import { ALLOWED_METHODS } from '../condition-methods.js';
+const JoinGroupResultItem = Type.Object({
+    sum: Type.Optional(Type.Record(Type.String(), Type.Any())),
+    min: Type.Optional(Type.Record(Type.String(), Type.Any())),
+    max: Type.Optional(Type.Record(Type.String(), Type.Any())),
+    distinctCount: Type.Optional(Type.Record(Type.String(), Type.Any())),
+    rows: Type.Optional(Type.Array(Type.Any())),
+});
+export function SearchTableBodyPost(dbTables, tableName) {
+    const tableConf = dbTables[tableName];
+    const schema = tableConf.Schema;
+    // Filters: schema fields + extraFilters
+    const filterFields = {
+        ...schema.fields,
+        ...tableConf.extraFilters,
+    };
+    const filtersSchema = Type.Optional(Type.Partial(Type.Object(filterFields)));
+    // Joins & JoinGroups from allowedReadJoins
+    const joinProperties = {};
+    const joinFilterProperties = {};
+    const joinGroupProperties = {};
+    if (tableConf.allowedReadJoins) {
+        for (const [joinSchema] of tableConf.allowedReadJoins) {
+            const joinTableName = joinSchema.tableName;
+            const joinTableConf = dbTables[joinTableName];
+            const joinFilterFields = joinTableConf
+                ? { ...joinSchema.fields, ...joinTableConf.extraFilters }
+                : { ...joinSchema.fields };
+            joinProperties[joinTableName] = Type.Object({
+                filters: Type.Optional(Type.Partial(Type.Object(joinFilterFields))),
+            });
+            joinFilterProperties[joinTableName] = Type.Partial(Type.Object(joinFilterFields));
+            joinGroupProperties[joinTableName] = Type.Object({
+                aggregations: Type.Object({
+                    by: Type.Optional(Type.String()),
+                    distinctCount: Type.Optional(Type.Array(Type.String())),
+                    min: Type.Optional(Type.Array(Type.String())),
+                    max: Type.Optional(Type.Array(Type.String())),
+                    sum: Type.Optional(Type.Array(Type.String())),
+                }),
+                filters: Type.Optional(Type.Partial(Type.Object(joinFilterFields))),
+            });
+        }
+    }
+    // Conditions: advanced filters with ConditionBuilder methods
+    const methodEnum = Type.Union(ALLOWED_METHODS.map((m) => Type.Literal(m)));
+    const conditionItemSchema = Type.Object({
+        field: Type.String(),
+        method: methodEnum,
+        params: Type.Optional(Type.Array(Type.Any())),
+    });
+    const bodyProperties = {
+        filters: filtersSchema,
+        conditions: Type.Optional(Type.Array(conditionItemSchema)),
+    };
+    if (Object.keys(joinProperties).length > 0) {
+        bodyProperties.joinFilters = Type.Optional(Type.Partial(Type.Object(joinFilterProperties)));
+        bodyProperties.joins = Type.Optional(Type.Partial(Type.Object(joinProperties)));
+        bodyProperties.joinGroups = Type.Optional(Type.Partial(Type.Object(joinGroupProperties)));
+    }
+    return Type.Object(bodyProperties);
+}
+export const SearchTableQueryString = Type.Object({
+    orderBy: Type.Optional(Type.String()),
+    page: Type.Optional(Type.Integer({ minimum: 1 })),
+    itemsPerPage: Type.Optional(Type.Integer({ minimum: 1, maximum: 5000, default: 500 })),
+    computeMin: Type.Optional(Type.String()),
+    computeMax: Type.Optional(Type.String()),
+    computeSum: Type.Optional(Type.String()),
+    computeAvg: Type.Optional(Type.String()),
+});
+export function SearchTableResponse(dbTables, tableName) {
+    const tableConf = dbTables[tableName];
+    const mainItem = Type.Partial(Type.Object(tableConf.Schema.fields));
+    const joinResponseProperties = {};
+    const joinGroupResponseProperties = {};
+    if (tableConf.allowedReadJoins) {
+        for (const [joinSchema] of tableConf.allowedReadJoins) {
+            joinResponseProperties[joinSchema.tableName] = Type.Array(Type.Partial(Type.Object(joinSchema.fields)));
+            joinGroupResponseProperties[joinSchema.tableName] = JoinGroupResultItem;
+        }
+    }
+    return Type.Object({
+        table: Type.String(),
+        main: Type.Array(mainItem),
+        joins: Type.Optional(Type.Partial(Type.Object(joinResponseProperties))),
+        joinGroups: Type.Optional(Type.Partial(Type.Object(joinGroupResponseProperties))),
+        pagination: Type.Optional(Type.Object({
+            total: Type.Integer(),
+            pages: Type.Integer(),
+            computed: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+            paginator: Type.Object({
+                page: Type.Integer(),
+                itemsPerPage: Type.Integer(),
+            }),
+        })),
+    });
+}

package/dist/lib/schema/update.d.ts

@@ -0,0 +1,5 @@
+import { type TObject } from '@sinclair/typebox';
+import type { DbTables } from '../../types.js';
+export declare function UpdateTableBody(dbTables: DbTables, tableName: string): TObject;
+export declare function UpdateTableResponse(dbTables: DbTables, tableName: string): TObject;
+//# sourceMappingURL=update.d.ts.map

package/dist/lib/schema/update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["../../../src/lib/schema/update.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,OAAO,EAAgB,MAAM,mBAAmB,CAAC;AAErE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAI/C,wBAAgB,eAAe,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAqC9E;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CA8BlF"}

package/dist/lib/schema/update.js

@@ -0,0 +1,47 @@
+import { Type } from '@sinclair/typebox';
+import { primaryAsString } from '../../types.js';
+import { findSecondaryTableConf } from '../engine/write-helpers.js';
+import { pkSchema, buildSecondaryFields } from './helpers.js';
+export function UpdateTableBody(dbTables, tableName) {
+    const tableConf = dbTables[tableName];
+    const schema = tableConf.Schema;
+    // Main: PK required, all other fields optional
+    const mainFields = {};
+    for (const [key, value] of Object.entries(schema.fields)) {
+        mainFields[key] = key === primaryAsString(tableConf.primary) ? value : Type.Optional(value);
+    }
+    const bodyProperties = {
+        main: Type.Object(mainFields),
+    };
+    if (tableConf.allowedWriteJoins?.length) {
+        const secondaryProperties = {};
+        const deletionProperties = {};
+        for (const [joinSchema, joinField] of tableConf.allowedWriteJoins) {
+            const secondaryTableConf = findSecondaryTableConf(dbTables, joinSchema.tableName);
+            const joinFields = buildSecondaryFields(joinSchema, joinField, secondaryTableConf);
+            secondaryProperties[joinSchema.tableName] = Type.Array(Type.Object(joinFields));
+            deletionProperties[joinSchema.tableName] = Type.Array(Type.Partial(Type.Object(joinSchema.fields)));
+        }
+        bodyProperties.secondaries = Type.Optional(Type.Partial(Type.Object(secondaryProperties)));
+        bodyProperties.deletions = Type.Optional(Type.Partial(Type.Object(deletionProperties)));
+    }
+    return Type.Object(bodyProperties);
+}
+export function UpdateTableResponse(dbTables, tableName) {
+    const tableConf = dbTables[tableName];
+    const responseProperties = {
+        main: Type.Object(pkSchema(tableConf, tableConf.Schema, primaryAsString(tableConf.primary))),
+    };
+    if (tableConf.allowedWriteJoins?.length) {
+        const secondaryProperties = {};
+        const deletionProperties = {};
+        for (const [joinSchema, joinField] of tableConf.allowedWriteJoins) {
+            const secondaryTableConf = findSecondaryTableConf(dbTables, joinSchema.tableName);
+            secondaryProperties[joinSchema.tableName] = Type.Array(Type.Object(pkSchema(secondaryTableConf, joinSchema, joinField)));
+            deletionProperties[joinSchema.tableName] = Type.Array(Type.Partial(Type.Object(joinSchema.fields)));
+        }
+        responseProperties.secondaries = Type.Optional(Type.Partial(Type.Object(secondaryProperties)));
+        responseProperties.deletions = Type.Optional(Type.Partial(Type.Object(deletionProperties)));
+    }
+    return Type.Object(responseProperties);
+}

package/dist/lib/setup-swagger.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyInstance } from 'fastify';
+import type { SqlApiPluginOptions } from '../types.js';
+export declare function setupSwagger(fastify: FastifyInstance, options: Pick<SqlApiPluginOptions, 'swagger'>): Promise<void>;
+//# sourceMappingURL=setup-swagger.d.ts.map

package/dist/lib/setup-swagger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup-swagger.d.ts","sourceRoot":"","sources":["../../src/lib/setup-swagger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,KAAK,EAAE,mBAAmB,EAAkB,MAAM,aAAa,CAAC;AAEvE,wBAAsB,YAAY,CAChC,OAAO,EAAE,eAAe,EACxB,OAAO,EAAE,IAAI,CAAC,mBAAmB,EAAE,SAAS,CAAC,GAC5C,OAAO,CAAC,IAAI,CAAC,CA6Bf"}

package/dist/lib/setup-swagger.js

@@ -0,0 +1,27 @@
+export async function setupSwagger(fastify, options) {
+    if (!options.swagger)
+        return;
+    if (fastify.hasDecorator('swagger'))
+        return;
+    try {
+        const swaggerMod = await import('@fastify/swagger');
+        const swaggerUiMod = await import('@fastify/swagger-ui');
+        const swaggerConf = typeof options.swagger === 'object' ? options.swagger : {};
+        await fastify.register(swaggerMod.default, {
+            openapi: {
+                info: {
+                    title: swaggerConf.title || 'SqlAPI Documentation',
+                    description: swaggerConf.description || 'Auto-generated API documentation',
+                    version: swaggerConf.version || '1.0.0',
+                },
+            },
+        });
+        await fastify.register(swaggerUiMod.default, {
+            routePrefix: swaggerConf.routePrefix || '/documentation',
+            indexPrefix: fastify.prefix,
+        });
+    }
+    catch {
+        fastify.log.warn('swagger: true requires @fastify/swagger and @fastify/swagger-ui. Install them: npm i @fastify/swagger @fastify/swagger-ui');
+    }
+}

package/dist/lib/sql-api.d.ts

@@ -0,0 +1,49 @@
+import type { FastifyRequest } from 'fastify';
+import { QueryClient } from './db.js';
+import { type DialectName } from './dialect.js';
+import type { DbTables, Queryable, FilterRecord, SearchCondition, Paginator, JoinGroupRequest, SearchResult, GetResult, InsertResult, UpdateResult, DeleteResult, BulkUpsertItem, BulkUpsertResult, BulkDeleteResult, TenantId } from '../types.js';
+export interface SqlApiSearchParams {
+    filters?: FilterRecord;
+    conditions?: SearchCondition[];
+    joinFilters?: Record<string, FilterRecord>;
+    joins?: Record<string, {
+        filters?: FilterRecord;
+    }>;
+    joinGroups?: Record<string, JoinGroupRequest>;
+    orderBy?: string;
+    paginator?: Paginator;
+    computeMin?: string;
+    computeMax?: string;
+    computeSum?: string;
+    computeAvg?: string;
+}
+export interface SqlApiInsertParams {
+    record: Record<string, unknown>;
+    secondaries?: Record<string, Record<string, unknown>[]>;
+}
+export interface SqlApiUpdateParams {
+    record: Record<string, unknown>;
+    secondaries?: Record<string, Record<string, unknown>[]>;
+    deletions?: Record<string, Record<string, unknown>[]>;
+}
+export interface SqlApiOptions {
+    dialect?: DialectName;
+    getTenantId?: (request: FastifyRequest) => TenantId | TenantId[] | null | undefined | Promise<TenantId | TenantId[] | null | undefined>;
+}
+export declare class SqlApi {
+    private dbTables;
+    private options;
+    private db;
+    constructor(dbOrPool: QueryClient | Queryable, dbTables: DbTables, options?: SqlApiOptions);
+    private getTableConf;
+    private getTenant;
+    search(tableName: string, params?: SqlApiSearchParams, request?: FastifyRequest): Promise<SearchResult>;
+    get(tableName: string, id: string | number, request?: FastifyRequest): Promise<GetResult>;
+    insert(tableName: string, params: SqlApiInsertParams, request?: FastifyRequest): Promise<InsertResult>;
+    update(tableName: string, params: SqlApiUpdateParams, request?: FastifyRequest): Promise<UpdateResult>;
+    delete(tableName: string, id: string | number, request?: FastifyRequest): Promise<DeleteResult>;
+    bulkUpsert(tableName: string, items: BulkUpsertItem[], request?: FastifyRequest): Promise<BulkUpsertResult[]>;
+    bulkDelete(tableName: string, ids: (string | number)[], request?: FastifyRequest): Promise<BulkDeleteResult[]>;
+}
+export declare function createSqlApi(dbOrPool: QueryClient | Queryable, dbTables: DbTables, options?: SqlApiOptions): SqlApi;
+//# sourceMappingURL=sql-api.d.ts.map

package/dist/lib/sql-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-api.d.ts","sourceRoot":"","sources":["../../src/lib/sql-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,OAAO,EAAqB,WAAW,EAAE,MAAM,SAAS,CAAC;AACzD,OAAO,EAAc,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAS5D,OAAO,KAAK,EACV,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,eAAe,EACf,SAAS,EACT,gBAAgB,EAChB,YAAY,EACZ,SAAS,EACT,YAAY,EACZ,YAAY,EACZ,YAAY,EACZ,cAAc,EACd,gBAAgB,EAChB,gBAAgB,EAChB,QAAQ,EAGT,MAAM,aAAa,CAAC;AAIrB,MAAM,WAAW,kBAAkB;IACjC,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,UAAU,CAAC,EAAE,eAAe,EAAE,CAAC;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,OAAO,CAAC,EAAE,YAAY,CAAA;KAAE,CAAC,CAAC;IACnD,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC9C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;CACzD;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;IACxD,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;CACvD;AAID,MAAM,WAAW,aAAa;IAC5B,OAAO,CAAC,EAAE,WAAW,CAAC;IACtB,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,QAAQ,GAAG,QAAQ,EAAE,GAAG,IAAI,GAAG,SAAS,GAC/E,OAAO,CAAC,QAAQ,GAAG,QAAQ,EAAE,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC;CACvD;AAED,qBAAa,MAAM;IAKf,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,OAAO;IALjB,OAAO,CAAC,EAAE,CAAc;gBAGtB,QAAQ,EAAE,WAAW,GAAG,SAAS,EACzB,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,aAAkB;IAgBrC,OAAO,CAAC,YAAY;YAUN,SAAS;IAUjB,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,GAAE,kBAAuB,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,YAAY,CAAC;IAqB3G,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,SAAS,CAAC;IAMzF,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,kBAAkB,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,YAAY,CAAC;IActG,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,kBAAkB,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,YAAY,CAAC;IAetG,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,YAAY,CAAC;IAM/F,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,cAAc,EAAE,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAa7G,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC;CAKrH;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,WAAW,GAAG,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,MAAM,CAEnH"}

package/dist/lib/sql-api.js

@@ -0,0 +1,124 @@
+import { ConditionBuilder } from 'node-condition-builder';
+import { createQueryClient, QueryClient } from './db.js';
+import { getDialect } from './dialect.js';
+import { resolveTenant } from './tenant.js';
+import { searchEngine } from './engine/search/search.js';
+import { getEngine } from './engine/rest/get.js';
+import { insertEngine } from './engine/rest/insert.js';
+import { updateEngine } from './engine/rest/update.js';
+import { deleteEngine } from './engine/rest/delete.js';
+import { bulkUpsertEngine } from './engine/bulk/bulk-upsert.js';
+import { bulkDeleteEngine } from './engine/bulk/bulk-delete.js';
+export class SqlApi {
+    dbTables;
+    options;
+    db;
+    constructor(dbOrPool, dbTables, options = {}) {
+        this.dbTables = dbTables;
+        this.options = options;
+        // Accept either a QueryClient or a raw Queryable pool
+        if (dbOrPool instanceof QueryClient) {
+            this.db = dbOrPool;
+        }
+        else {
+            this.db = createQueryClient(dbOrPool, options.dialect);
+        }
+        // Set ConditionBuilder dialect (used by filters built via exportTableInfo)
+        if (options.dialect) {
+            const dialect = getDialect(options.dialect);
+            ConditionBuilder.DIALECT = dialect.cbDialect;
+        }
+    }
+    getTableConf(tableName) {
+        const conf = this.dbTables[tableName];
+        if (!conf) {
+            const err = new Error(`Table "${tableName}" not found in DbTables`);
+            err.statusCode = 400;
+            throw err;
+        }
+        return conf;
+    }
+    async getTenant(tableName, request) {
+        if (!request || !this.options.getTenantId)
+            return undefined;
+        const tableConf = this.getTableConf(tableName);
+        return resolveTenant({ DbTables: this.dbTables, getTenantId: this.options.getTenantId }, tableConf, request);
+    }
+    async search(tableName, params = {}, request) {
+        const tableConf = this.getTableConf(tableName);
+        const tenant = await this.getTenant(tableName, request);
+        return searchEngine(this.dbTables, {
+            db: this.db,
+            tableConf,
+            filters: params.filters,
+            conditions: params.conditions,
+            joinFilters: params.joinFilters,
+            joins: params.joins,
+            joinGroups: params.joinGroups,
+            orderBy: params.orderBy,
+            paginator: params.paginator,
+            computeMin: params.computeMin,
+            computeMax: params.computeMax,
+            computeSum: params.computeSum,
+            computeAvg: params.computeAvg,
+            tenant,
+        });
+    }
+    async get(tableName, id, request) {
+        const tableConf = this.getTableConf(tableName);
+        const tenant = await this.getTenant(tableName, request);
+        return getEngine({ db: this.db, tableConf, id, tenant });
+    }
+    async insert(tableName, params, request) {
+        const tableConf = this.getTableConf(tableName);
+        const tenant = await this.getTenant(tableName, request);
+        return insertEngine({
+            db: this.db,
+            tableConf,
+            dbTables: this.dbTables,
+            request: request,
+            record: params.record,
+            secondaries: params.secondaries,
+            tenant,
+        });
+    }
+    async update(tableName, params, request) {
+        const tableConf = this.getTableConf(tableName);
+        const tenant = await this.getTenant(tableName, request);
+        return updateEngine({
+            db: this.db,
+            tableConf,
+            dbTables: this.dbTables,
+            request: request,
+            record: params.record,
+            secondaries: params.secondaries,
+            deletions: params.deletions,
+            tenant,
+        });
+    }
+    async delete(tableName, id, request) {
+        const tableConf = this.getTableConf(tableName);
+        const tenant = await this.getTenant(tableName, request);
+        return deleteEngine({ db: this.db, tableConf, id, tenant });
+    }
+    async bulkUpsert(tableName, items, request) {
+        const tableConf = this.getTableConf(tableName);
+        const tenant = await this.getTenant(tableName, request);
+        return bulkUpsertEngine({
+            db: this.db,
+            tableConf,
+            dbTables: this.dbTables,
+            request: request,
+            items,
+            tenant,
+        });
+    }
+    async bulkDelete(tableName, ids, request) {
+        const tableConf = this.getTableConf(tableName);
+        const tenant = await this.getTenant(tableName, request);
+        return bulkDeleteEngine({ db: this.db, tableConf, ids, tenant });
+    }
+}
+export function createSqlApi(dbOrPool, dbTables, options) {
+    return new SqlApi(dbOrPool, dbTables, options);
+}

package/dist/lib/table-helpers.d.ts

@@ -0,0 +1,17 @@
+import { ConditionBuilder, type ConditionValueOrUndefined } from 'node-condition-builder';
+import type { TSchema, TObject } from '@sinclair/typebox';
+import type { SchemaDefinition, JoinDefinition, TableFilterFn, ITable } from '../types.js';
+type ExtraProps<EF> = EF extends TObject<infer P> ? P : EF extends Record<string, TSchema> ? EF : Record<string, never>;
+export declare function exportTableInfo<F extends Record<string, TSchema>, EF extends TObject | Record<string, TSchema> = Record<never, TSchema>>(Schema: SchemaDefinition<F>, extraFilters?: EF, extendedCondition?: (condition: ConditionBuilder, filters: {
+    [K in keyof F | keyof ExtraProps<EF>]?: ConditionValueOrUndefined;
+}) => void): {
+    Schema: SchemaDefinition<F>;
+    filters: TableFilterFn;
+    extraFilters: Record<string, TSchema>;
+};
+export declare function defineTable<F extends Record<string, TSchema>>(config: ITable<F>): ITable<F>;
+export declare function buildRelation<M extends Record<string, TSchema>, J extends Record<string, TSchema>>(mainSchema: SchemaDefinition<M>, mainField: string & keyof M | (string & keyof M)[], joinSchema: SchemaDefinition<J>, joinField: string & keyof J, selection?: string): JoinDefinition;
+export declare function buildUpsertRule<F extends Record<string, TSchema>>(schema: SchemaDefinition<F>, columns: (string & keyof F)[]): [SchemaDefinition, string[]];
+export declare function buildUpsertRules(...rules: [SchemaDefinition, string[]][]): Map<SchemaDefinition, string[]>;
+export {};
+//# sourceMappingURL=table-helpers.d.ts.map

package/dist/lib/table-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-helpers.d.ts","sourceRoot":"","sources":["../../src/lib/table-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,KAAK,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AAC1F,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EACV,gBAAgB,EAChB,cAAc,EACd,aAAa,EACb,MAAM,EACP,MAAM,aAAa,CAAC;AAGrB,KAAK,UAAU,CAAC,EAAE,IAAI,EAAE,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AAExH,wBAAgB,eAAe,CAC7B,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,EAAE,SAAS,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,EAErE,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAC3B,YAAY,GAAE,EAAa,EAC3B,iBAAiB,CAAC,EAAE,CAClB,SAAS,EAAE,gBAAgB,EAC3B,OAAO,EAAE;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,MAAM,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,yBAAyB;CAAE,KAC3E,IAAI,GACR;IAAE,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC;IAAC,OAAO,EAAE,aAAa,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CA0BhG;AAED,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC3D,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,GAChB,MAAM,CAAC,CAAC,CAAC,CAEX;AAED,wBAAgB,aAAa,CAC3B,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAEjC,UAAU,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAC/B,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,EAAE,EAClD,UAAU,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAC/B,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC,EAC3B,SAAS,GAAE,MAAY,GACtB,cAAc,CAEhB;AAED,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/D,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAC3B,OAAO,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,EAAE,GAC5B,CAAC,gBAAgB,EAAE,MAAM,EAAE,CAAC,CAE9B;AAED,wBAAgB,gBAAgB,CAC9B,GAAG,KAAK,EAAE,CAAC,gBAAgB,EAAE,MAAM,EAAE,CAAC,EAAE,GACvC,GAAG,CAAC,gBAAgB,EAAE,MAAM,EAAE,CAAC,CAEjC"}

package/dist/lib/table-helpers.js

@@ -0,0 +1,34 @@
+import { ConditionBuilder } from 'node-condition-builder';
+export function exportTableInfo(Schema, extraFilters = {}, extendedCondition) {
+    const filters = (filterValues) => {
+        const condition = new ConditionBuilder('AND');
+        // Only auto-match real schema fields (DB columns)
+        for (const field of Object.keys(Schema.fields)) {
+            if (field in filterValues && filterValues[field] !== null && filterValues[field] !== undefined) {
+                condition.isEqual(Schema.col(field), filterValues[field]);
+            }
+        }
+        // extraFilters are handled exclusively by extendedCondition
+        if (extendedCondition) {
+            extendedCondition(condition, filterValues);
+        }
+        return condition;
+    };
+    // Extract properties from TObject or use as-is
+    const efRecord = (extraFilters && typeof extraFilters === 'object' && 'properties' in extraFilters)
+        ? extraFilters.properties
+        : extraFilters;
+    return { Schema, filters, extraFilters: efRecord };
+}
+export function defineTable(config) {
+    return config;
+}
+export function buildRelation(mainSchema, mainField, joinSchema, joinField, selection = '*') {
+    return [joinSchema, joinField, mainField, selection];
+}
+export function buildUpsertRule(schema, columns) {
+    return [schema, columns];
+}
+export function buildUpsertRules(...rules) {
+    return new Map(rules);
+}

package/dist/lib/tenant.d.ts

@@ -0,0 +1,19 @@
+import type { FastifyRequest } from 'fastify';
+import type { QueryClient } from './db.js';
+import { ConditionBuilder, type ConditionValue, type ConditionValueOrUndefined } from 'node-condition-builder';
+import type { ITable, SqlApiPluginOptions, TenantId, TenantScope, TenantScopeIndirect, TenantContext } from '../types.js';
+export declare function resolveTenant(options: SqlApiPluginOptions, tableConf: ITable, request: FastifyRequest): Promise<TenantContext | undefined>;
+export declare function buildTenantCondition(db: QueryClient, scope: TenantScope, tenantIds: TenantId[]): ConditionBuilder;
+export declare function buildTenantJoin(db: QueryClient, scope: TenantScopeIndirect, mainTableName: string): string;
+export declare function injectTenantValue(record: Record<string, unknown>, scope: TenantScope, tenantIds: TenantId[]): void;
+export declare function validateTenantFK(db: QueryClient, scope: TenantScopeIndirect, tenantIds: TenantId[], fkValues: unknown[]): Promise<void>;
+/**
+ * Build WHERE clause for DELETE with tenant filtering.
+ * Handles both direct (simple AND) and indirect (subquery via JOIN) scopes.
+ */
+export declare function buildTenantDeleteWhere(db: QueryClient, tableName: string, pkCol: string, pkValue: ConditionValueOrUndefined | ConditionValue[], tenant: TenantContext): {
+    where: string;
+    values: unknown[];
+};
+export declare function stripTenantColumn(fields: Record<string, unknown>, scope: TenantScope): void;
+//# sourceMappingURL=tenant.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tenant.d.ts","sourceRoot":"","sources":["../../src/lib/tenant.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,EAAE,gBAAgB,EAAE,KAAK,cAAc,EAAE,KAAK,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AAC/G,OAAO,KAAK,EACV,MAAM,EACN,mBAAmB,EACnB,QAAQ,EACR,WAAW,EACX,mBAAmB,EACnB,aAAa,EACd,MAAM,aAAa,CAAC;AAMrB,wBAAsB,aAAa,CACjC,OAAO,EAAE,mBAAmB,EAC5B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CASpC;AAED,wBAAgB,oBAAoB,CAClC,EAAE,EAAE,WAAW,EACf,KAAK,EAAE,WAAW,EAClB,SAAS,EAAE,QAAQ,EAAE,GACpB,gBAAgB,CAclB;AAED,wBAAgB,eAAe,CAC7B,EAAE,EAAE,WAAW,EACf,KAAK,EAAE,mBAAmB,EAC1B,aAAa,EAAE,MAAM,GACpB,MAAM,CAMR;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,KAAK,EAAE,WAAW,EAClB,SAAS,EAAE,QAAQ,EAAE,GACpB,IAAI,CAqBN;AAED,wBAAsB,gBAAgB,CACpC,EAAE,EAAE,WAAW,EACf,KAAK,EAAE,mBAAmB,EAC1B,SAAS,EAAE,QAAQ,EAAE,EACrB,QAAQ,EAAE,OAAO,EAAE,GAClB,OAAO,CAAC,IAAI,CAAC,CA2Bf;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,WAAW,EACf,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,yBAAyB,GAAG,cAAc,EAAE,EACrD,MAAM,EAAE,aAAa,GACpB;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,EAAE,CAAA;CAAE,CAsBtC;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,KAAK,EAAE,WAAW,GACjB,IAAI,CAGN"}

package/dist/lib/tenant.js

@@ -0,0 +1,110 @@
+import { ConditionBuilder } from 'node-condition-builder';
+function isIndirect(scope) {
+    return 'through' in scope;
+}
+export async function resolveTenant(options, tableConf, request) {
+    if (!options.getTenantId)
+        return undefined;
+    if (!tableConf.tenantScope)
+        return undefined;
+    const raw = await options.getTenantId(request);
+    if (raw == null)
+        return undefined; // admin
+    const ids = Array.isArray(raw) ? raw : [raw];
+    return { ids, scope: tableConf.tenantScope };
+}
+export function buildTenantCondition(db, scope, tenantIds) {
+    const col = scope.column;
+    let qualifier;
+    if (isIndirect(scope)) {
+        const throughTable = scope.through.schema.tableName;
+        qualifier = `${db.qi(throughTable)}.${db.qi(col)}`;
+    }
+    else {
+        qualifier = db.qi(col);
+    }
+    const cb = new ConditionBuilder('AND');
+    cb.isIn(qualifier, tenantIds);
+    return cb;
+}
+export function buildTenantJoin(db, scope, mainTableName) {
+    const throughTable = scope.through.schema.tableName;
+    const localField = scope.through.localField;
+    const foreignField = scope.through.foreignField;
+    return `INNER JOIN ${db.qi(throughTable)} ON ${db.qi(mainTableName)}.${db.qi(localField)} = ${db.qi(throughTable)}.${db.qi(foreignField)}`;
+}
+export function injectTenantValue(record, scope, tenantIds) {
+    if (isIndirect(scope))
+        return;
+    const col = scope.column;
+    if (col in record) {
+        if (!tenantIds.includes(record[col])) {
+            const err = new Error('Access denied: tenant value does not match');
+            err.statusCode = 403;
+            throw err;
+        }
+        return;
+    }
+    if (tenantIds.length === 1) {
+        record[col] = tenantIds[0];
+        return;
+    }
+    const err = new Error('Ambiguous tenant: specify the tenant value');
+    err.statusCode = 400;
+    throw err;
+}
+export async function validateTenantFK(db, scope, tenantIds, fkValues) {
+    if (!fkValues.length)
+        return;
+    const uniqueFKs = [...new Set(fkValues.filter((v) => v != null))];
+    if (!uniqueFKs.length)
+        return;
+    const throughTable = scope.through.schema.tableName;
+    const foreignField = scope.through.foreignField;
+    const tenantCol = scope.column;
+    const cb = new ConditionBuilder('AND');
+    cb.isIn(db.qi(foreignField), uniqueFKs);
+    cb.isNotIn(db.qi(tenantCol), tenantIds);
+    const where = cb.build(1, db.ph);
+    const values = cb.getValues();
+    const sql = `SELECT ${db.qi(foreignField)} FROM ${db.qi(throughTable)} ` +
+        `WHERE ${where}`;
+    const result = await db.query(sql, values);
+    if (result.rows.length > 0) {
+        const err = new Error('Access denied: records do not belong to tenant');
+        err.statusCode = 403;
+        throw err;
+    }
+}
+/**
+ * Build WHERE clause for DELETE with tenant filtering.
+ * Handles both direct (simple AND) and indirect (subquery via JOIN) scopes.
+ */
+export function buildTenantDeleteWhere(db, tableName, pkCol, pkValue, tenant) {
+    if (isIndirect(tenant.scope)) {
+        const innerCb = new ConditionBuilder('AND');
+        innerCb.isIn(`${db.qi(tableName)}.${db.qi(pkCol)}`, (Array.isArray(pkValue) ? pkValue : [pkValue]));
+        innerCb.append(buildTenantCondition(db, tenant.scope, tenant.ids));
+        const innerWhere = innerCb.build(1, db.ph);
+        const values = innerCb.getValues();
+        const joinSql = buildTenantJoin(db, tenant.scope, tableName);
+        const where = `${db.qi(pkCol)} IN (SELECT ${db.qi(tableName)}.${db.qi(pkCol)} FROM ${db.qi(tableName)} ${joinSql} WHERE ${innerWhere})`;
+        return { where, values };
+    }
+    const cb = new ConditionBuilder('AND');
+    if (Array.isArray(pkValue)) {
+        cb.isIn(db.qi(pkCol), pkValue);
+    }
+    else {
+        cb.isEqual(db.qi(pkCol), pkValue);
+    }
+    cb.append(buildTenantCondition(db, tenant.scope, tenant.ids));
+    const where = cb.build(1, db.ph);
+    const values = cb.getValues();
+    return { where, values };
+}
+export function stripTenantColumn(fields, scope) {
+    if (isIndirect(scope))
+        return;
+    delete fields[scope.column];
+}

package/dist/routes/auto/bulk-delete.routes.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyInstance } from 'fastify';
+import type { SqlApiPluginOptions } from '../../types.js';
+export default function bulkDeleteRoutes(fastify: FastifyInstance, options: SqlApiPluginOptions): Promise<void>;
+//# sourceMappingURL=bulk-delete.routes.d.ts.map

package/dist/routes/auto/bulk-delete.routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bulk-delete.routes.d.ts","sourceRoot":"","sources":["../../../src/routes/auto/bulk-delete.routes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAI/C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAE1D,wBAA8B,gBAAgB,CAC5C,OAAO,EAAE,eAAe,EACxB,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,IAAI,CAAC,CAyBf"}

package/dist/routes/auto/bulk-delete.routes.js

@@ -0,0 +1,27 @@
+import { BulkDeleteTableBody, BulkDeleteTableResponse } from '../../lib/schema/bulk-delete.js';
+import { primaryAsString } from '../../types.js';
+import { mergeOnRequests } from './route-helpers.js';
+export default async function bulkDeleteRoutes(fastify, options) {
+    const { DbTables } = options;
+    for (const [tableName, tableConf] of Object.entries(DbTables)) {
+        const bodySchema = BulkDeleteTableBody(DbTables, tableName);
+        const responseSchema = BulkDeleteTableResponse(DbTables, tableName);
+        fastify.route({
+            method: 'POST',
+            url: `/bulk/${tableConf.Schema.tableName}/delete`,
+            schema: {
+                body: bodySchema,
+                response: { 200: responseSchema },
+                tags: [`SqlAPI-${tableName}`],
+                summary: `Bulk delete ${tableName}`,
+                description: `Delete multiple records from ${tableName} by primary key`,
+            },
+            onRequest: mergeOnRequests(options, tableConf),
+            handler: async (request, reply) => {
+                const items = request.body;
+                const ids = items.map((item) => item[primaryAsString(tableConf.primary)]);
+                reply.send(await fastify.sqlApi.bulkDelete(tableName, ids, request));
+            },
+        });
+    }
+}

package/dist/routes/auto/bulk-upsert.routes.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyInstance } from 'fastify';
+import type { SqlApiPluginOptions } from '../../types.js';
+export default function bulkUpsertRoutes(fastify: FastifyInstance, options: SqlApiPluginOptions): Promise<void>;
+//# sourceMappingURL=bulk-upsert.routes.d.ts.map

package/dist/routes/auto/bulk-upsert.routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bulk-upsert.routes.d.ts","sourceRoot":"","sources":["../../../src/routes/auto/bulk-upsert.routes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAG/C,OAAO,KAAK,EAAE,mBAAmB,EAAkB,MAAM,gBAAgB,CAAC;AAE1E,wBAA8B,gBAAgB,CAC5C,OAAO,EAAE,eAAe,EACxB,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,IAAI,CAAC,CAwBf"}

package/dist/routes/auto/bulk-upsert.routes.js

@@ -0,0 +1,25 @@
+import { BulkUpsertTableBody, BulkUpsertTableResponse } from '../../lib/schema/bulk-upsert.js';
+import { mergeOnRequests, buildWriteDescription } from './route-helpers.js';
+export default async function bulkUpsertRoutes(fastify, options) {
+    const { DbTables } = options;
+    for (const [tableName, tableConf] of Object.entries(DbTables)) {
+        const bodySchema = BulkUpsertTableBody(DbTables, tableName);
+        const responseSchema = BulkUpsertTableResponse(DbTables, tableName);
+        fastify.route({
+            method: 'PUT',
+            url: `/bulk/${tableConf.Schema.tableName}`,
+            schema: {
+                body: bodySchema,
+                response: { 200: responseSchema },
+                tags: [`SqlAPI-${tableName}`],
+                summary: `Bulk upsert ${tableName}`,
+                description: buildWriteDescription('Bulk upsert records in', tableName, tableConf),
+            },
+            onRequest: mergeOnRequests(options, tableConf),
+            handler: async (request, reply) => {
+                const items = request.body;
+                reply.send(await fastify.sqlApi.bulkUpsert(tableName, items, request));
+            },
+        });
+    }
+}

package/dist/routes/auto/delete.routes.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyInstance } from 'fastify';
+import type { SqlApiPluginOptions } from '../../types.js';
+export default function deleteRoutes(fastify: FastifyInstance, options: SqlApiPluginOptions): Promise<void>;
+//# sourceMappingURL=delete.routes.d.ts.map