@feasibleone/blong-gogo 1.26.0 → 1.28.0

package/src/adapter/schema/knex/json.test.ts

@@ -0,0 +1,243 @@
+/**
+ * Unit tests for the knex JSON-column interception (json.ts).
+ *
+ * Verifies that:
+ *  - object/array values for `*JSON` columns are serialized to strings on write
+ *  - `*JSON` string values are parsed back to objects on read (lenient)
+ *  - `wrapJsonBuilder` intercepts insert/update inputs and query results
+ */
+
+import {test} from 'tap';
+
+import {
+    isDeadlock,
+    parseJsonResult,
+    parseJsonRow,
+    stringifyJsonValues,
+    wrapJsonBuilder,
+    wrapKnex,
+} from './json.ts';
+
+test('stringifyJsonValues serializes object/array values for *JSON columns only', t => {
+    const out = stringifyJsonValues({
+        credentialParamsJSON: {function: 'hash', iterations: 100000},
+        flowStepsJSON: ['password', 'totp'],
+        credentialSalt: 'salt',
+        credentialType: 'password',
+    });
+    t.equal(out.credentialParamsJSON, '{"function":"hash","iterations":100000}');
+    t.equal(out.flowStepsJSON, '["password","totp"]');
+    t.equal(out.credentialSalt, 'salt');
+    t.equal(out.credentialType, 'password');
+    t.end();
+});
+
+test('stringifyJsonValues leaves already-string *JSON values untouched', t => {
+    const out = stringifyJsonValues({credentialParamsJSON: '{"a":1}', userId: 'u1'});
+    t.equal(out.credentialParamsJSON, '{"a":1}');
+    t.equal(out.userId, 'u1');
+    t.end();
+});
+
+test('parseJsonRow parses *JSON strings, keeps invalid JSON and non-JSON columns', t => {
+    const row = parseJsonRow({
+        credentialParamsJSON: '{"function":"hash"}',
+        configJSON: 'not-json',
+        credentialSalt: 'salt',
+    });
+    t.same(row.credentialParamsJSON, {function: 'hash'});
+    t.equal(row.configJSON, 'not-json');
+    t.equal(row.credentialSalt, 'salt');
+    t.end();
+});
+
+test('parseJsonResult handles single row, row arrays and [rows, meta] DML shapes', t => {
+    // single row
+    t.same(parseJsonResult({credentialParamsJSON: '{"a":1}'}), {
+        credentialParamsJSON: {a: 1},
+    });
+    // array of rows
+    t.same(
+        parseJsonResult([{credentialParamsJSON: '{"a":1}'}, {credentialParamsJSON: '{"b":2}'}]),
+        [{credentialParamsJSON: {a: 1}}, {credentialParamsJSON: {b: 2}}],
+    );
+    // [rows, meta] from MySQL DML — meta object is left untouched
+    const dml = parseJsonResult([{fieldCount: 0, insertId: 1}, undefined]) as Array<unknown>;
+    t.equal((dml[0] as Record<string, unknown>).insertId, 1);
+    // scalars pass through
+    t.equal(parseJsonResult(3), 3);
+    t.end();
+});
+
+test('wrapJsonBuilder serializes JSON columns on insert/update and parses on then', async t => {
+    const captured: Array<Record<string, unknown>> = [];
+    const builder = {
+        _result: undefined as unknown,
+        insert(value: Record<string, unknown>) {
+            captured.push(value);
+            return this;
+        },
+        update(value: Record<string, unknown>) {
+            captured.push(value);
+            return this;
+        },
+        then(onFulfilled: (value: unknown) => unknown) {
+            return Promise.resolve(this._result).then(onFulfilled);
+        },
+    };
+    const wrapped = wrapJsonBuilder(builder);
+
+    // insert — object JSON column is serialized, other columns unchanged
+    const insertResult = wrapped.insert({credentialParamsJSON: {function: 'hash'}, userId: 1});
+    t.equal(insertResult, builder, 'insert returns the same builder for chaining');
+    t.equal(captured[0].credentialParamsJSON, '{"function":"hash"}');
+    t.equal(captured[0].userId, 1);
+
+    // update — same serialization
+    wrapped.update({credentialParamsJSON: {function: 'totp', digits: 6}});
+    t.equal(captured[1].credentialParamsJSON, '{"function":"totp","digits":6}');
+
+    // then — result rows have *JSON strings parsed back to objects
+    (builder as unknown as {_result: unknown})._result = {
+        credentialParamsJSON: '{"function":"hash","iterations":100000}',
+        credentialSalt: 'salt',
+    };
+    const row = (await wrapped.then((value: unknown) => value)) as Record<string, unknown>;
+    t.same(row.credentialParamsJSON, {function: 'hash', iterations: 100000});
+    t.equal(row.credentialSalt, 'salt');
+    t.end();
+});
+
+test('isDeadlock detects MySQL deadlock errors', t => {
+    t.equal(isDeadlock({errno: 1213}), true, 'errno 1213');
+    t.equal(isDeadlock({code: 'ER_LOCK_DEADLOCK'}), true, 'ER_LOCK_DEADLOCK code');
+    t.equal(
+        isDeadlock({errno: 1213, code: 'ER_LOCK_DEADLOCK', sql: 'UPDATE t SET x = 1'}),
+        true,
+        'deadlock with sql',
+    );
+    t.equal(isDeadlock({errno: 1062}), false, 'non-deadlock errno');
+    t.equal(isDeadlock(new Error('boom')), false, 'plain error');
+    t.equal(isDeadlock(null), false, 'null');
+    t.equal(isDeadlock('ER_LOCK_DEADLOCK'), false, 'string');
+    t.end();
+});
+
+test('wrapJsonBuilder reports deadlocks via onDeadlock and preserves rejection', async t => {
+    const deadlock = {
+        errno: 1213,
+        code: 'ER_LOCK_DEADLOCK',
+        sql: 'UPDATE `t` set `x` = 1',
+        sqlMessage: 'Deadlock found when trying to get lock',
+    };
+    const reported: unknown[] = [];
+    const builder = wrapJsonBuilder(makeRejectingBuilder(deadlock), {
+        onDeadlock: error => reported.push(error),
+    });
+
+    await t.rejects(Promise.resolve(builder.then(null, null)), deadlock, 'query still rejects');
+    t.same(reported, [deadlock], 'onDeadlock fired once with the error');
+});
+
+test('wrapJsonBuilder passes non-deadlock errors through without reporting', async t => {
+    const boom = new Error('boom');
+    const reported: unknown[] = [];
+    const builder = wrapJsonBuilder(makeRejectingBuilder(boom), {
+        onDeadlock: error => reported.push(error),
+    });
+
+    await t.rejects(Promise.resolve(builder.then(null, null)), /boom/, 'error still propagates');
+    t.same(reported, [], 'onDeadlock not called');
+});
+
+test('wrapKnex raw() reports deadlocks via onDeadlock (stored-procedure / SQL calls)', async t => {
+    const deadlock = {
+        errno: 1213,
+        code: 'ER_LOCK_DEADLOCK',
+        sql: 'CALL `sql_deadlock`()',
+        sqlMessage: 'Deadlock found when trying to get lock',
+        message: 'Deadlock found when trying to get lock',
+    };
+    const reported: unknown[] = [];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const fakeKnex = (() => undefined) as any;
+    fakeKnex.raw = () => makeRejectingThenable(deadlock);
+    const wrapped = wrapKnex(fakeKnex, {onDeadlock: error => reported.push(error)});
+
+    const raw = wrapped.raw('CALL `sql_deadlock`()');
+    await t.rejects(Promise.resolve(raw.then(null, null)), deadlock, 'raw query still rejects');
+    t.same(reported, [deadlock], 'onDeadlock fired for the raw query');
+    t.end();
+});
+
+test('wrapKnex transaction() wraps the trx so its queries report deadlocks (callback form)', async t => {
+    const deadlock = {
+        errno: 1213,
+        code: 'ER_LOCK_DEADLOCK',
+        sql: 'UPDATE `deadlock_demo` set `x` = 1',
+        sqlMessage: 'Deadlock found when trying to get lock',
+        message: 'Deadlock found when trying to get lock',
+    };
+    const reported: unknown[] = [];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const fakeKnex = (() => undefined) as any;
+    fakeKnex.transaction = (cb: (trx: unknown) => unknown) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const trx = (() => makeRejectingBuilder(deadlock)) as any;
+        return Promise.resolve(cb(trx));
+    };
+    const wrapped = wrapKnex(fakeKnex, {onDeadlock: error => reported.push(error)});
+
+    await wrapped.transaction(async (trx: (...args: unknown[]) => unknown) => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const builder = trx('deadlock_demo') as any;
+        await t.rejects(Promise.resolve(builder.then(null, null)), deadlock, 'trx query rejects');
+    });
+    t.same(reported, [deadlock], 'onDeadlock fired for a transaction query');
+    t.end();
+});
+
+test('wrapKnex transaction() wraps the resolved trx (promise form)', async t => {
+    const deadlock = {errno: 1213, code: 'ER_LOCK_DEADLOCK'};
+    const reported: unknown[] = [];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const fakeKnex = (() => undefined) as any;
+    fakeKnex.transaction = () => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const trx = (() => makeRejectingBuilder(deadlock)) as any;
+        return Promise.resolve(trx);
+    };
+    const wrapped = wrapKnex(fakeKnex, {onDeadlock: error => reported.push(error)});
+
+    const trx = await wrapped.transaction();
+    const builder = trx('deadlock_demo');
+    await t.rejects(Promise.resolve(builder.then(null, null)), deadlock, 'trx query rejects');
+    t.same(reported, [deadlock], 'onDeadlock fired for a promise-form transaction query');
+    t.end();
+});
+
+/** A minimal knex-like builder whose `then` rejects with `error`. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function makeRejectingBuilder(error: unknown): any {
+    return {
+        insert(..._args: unknown[]) {
+            return this;
+        },
+        update(..._args: unknown[]) {
+            return this;
+        },
+        then(onFulfilled?: (value: unknown) => unknown, onRejected?: (reason: unknown) => unknown) {
+            return Promise.reject(error).then(onFulfilled, onRejected);
+        },
+    };
+}
+
+/** A minimal thenable whose `then` rejects with `error`. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function makeRejectingThenable(error: unknown): any {
+    return {
+        then(onFulfilled?: (value: unknown) => unknown, onRejected?: (reason: unknown) => unknown) {
+            return Promise.reject(error).then(onFulfilled, onRejected);
+        },
+    };
+}

package/src/adapter/schema/knex/json.ts

@@ -0,0 +1,213 @@
+/**
+ * JSON-column interception for the knex adapter.
+ *
+ * Any column whose name ends with `JSON` is treated as a JSON document stored
+ * in a plain string column.  The shared `srv.db` queryBuilder is wrapped so
+ * this conversion is automatic for every consumer of the adapter:
+ *
+ *  - `insert()` / `update()` — plain object/array values for `*JSON` columns
+ *    are serialized with `JSON.stringify` before hitting the database.
+ *  - query results (`select`, `first`, ...) — string values in `*JSON`
+ *    columns are parsed back with `JSON.parse` (lenient: values that are not
+ *    valid JSON are left untouched).
+ *
+ * This lets a realm store structured parameters in a single column without
+ * manual (de)serialization — e.g. blong-access stores the credential function
+ * and its parameters (`{"function":"hash","algorithm":"pbkdf2",...}`) in
+ * `access_credential.credentialParamsJSON`.
+ */
+
+/** Column names ending in `JSON` are treated as JSON documents. */
+const JSON_COLUMN = /JSON$/;
+
+/** Whether a column name is a JSON column (ends in `JSON`). */
+export function isJsonColumn(column: string): boolean {
+    return JSON_COLUMN.test(column);
+}
+
+/**
+ * Detect a MySQL deadlock error (errno 1213 / `ER_LOCK_DEADLOCK`). Used to log
+ * deadlock details — including the offending query — in dev mode.
+ */
+export function isDeadlock(error: unknown): boolean {
+    if (!error || typeof error !== 'object') return false;
+    const {code, errno} = error as {code?: unknown; errno?: unknown};
+    return code === 'ER_LOCK_DEADLOCK' || errno === 1213;
+}
+
+/**
+ * Optional hooks applied while wrapping the shared knex instance.
+ */
+export interface WrapKnexOptions {
+    /** Invoked when a query rejects with a deadlock error, before the caller's rejection handler. */
+    onDeadlock?: (error: unknown) => void;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Serialize object/array values of `*JSON` columns to JSON strings.
+ * Returns a new object; scalar/string values are copied unchanged.
+ */
+export function stringifyJsonValues(values: Record<string, unknown>): Record<string, unknown> {
+    const result: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(values)) {
+        result[key] =
+            JSON_COLUMN.test(key) && (isRecord(value) || Array.isArray(value))
+                ? JSON.stringify(value)
+                : value;
+    }
+    return result;
+}
+
+/** Parse `*JSON` string values in a single result row.  Mutates and returns the row. */
+export function parseJsonRow(row: Record<string, unknown>): Record<string, unknown> {
+    for (const [key, value] of Object.entries(row)) {
+        if (JSON_COLUMN.test(key) && typeof value === 'string') {
+            try {
+                row[key] = JSON.parse(value);
+            } catch {
+                // Not valid JSON — keep the raw string.
+            }
+        }
+    }
+    return row;
+}
+
+/**
+ * Parse `*JSON` columns in a query result.  Handles a single row, an array of
+ * rows, and the `[rows, meta]` shape MySQL returns for DML.  Rows are mutated
+ * in place; the overall result shape is preserved.
+ */
+export function parseJsonResult(result: unknown): unknown {
+    if (Array.isArray(result)) {
+        return result.map(row => (isRecord(row) ? parseJsonRow(row) : row));
+    }
+    if (isRecord(result)) return parseJsonRow(result);
+    return result;
+}
+
+/**
+ * Wrap a knex QueryBuilder instance so JSON columns are serialized on write and
+ * parsed on read.
+ *
+ * Only `insert`, `update`, and `then` are intercepted — all other builder
+ * behaviour is untouched.  Chained calls keep working because knex builder
+ * methods return the same instance.  The `then` rejection path is also
+ * intercepted to detect MySQL deadlocks and report them via `options.onDeadlock`.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function wrapJsonBuilder(builder: any, options: WrapKnexOptions = {}): any {
+    const originalInsert = builder.insert.bind(builder);
+    builder.insert = (...args: unknown[]) => {
+        const [first, ...rest] = args;
+        if (isRecord(first)) return originalInsert(stringifyJsonValues(first), ...rest);
+        if (Array.isArray(first))
+            return originalInsert(
+                first.map(row => (isRecord(row) ? stringifyJsonValues(row) : row)),
+                ...rest,
+            );
+        return originalInsert(...args);
+    };
+
+    const originalUpdate = builder.update.bind(builder);
+    builder.update = (...args: unknown[]) => {
+        const [first, ...rest] = args;
+        if (isRecord(first)) return originalUpdate(stringifyJsonValues(first), ...rest);
+        return originalUpdate(...args);
+    };
+
+    const originalThen = builder.then.bind(builder);
+    builder.then = (
+        onFulfilled?: ((value: unknown) => unknown) | null,
+        onRejected?: ((reason: unknown) => unknown) | null,
+    ) =>
+        originalThen(
+            (result: unknown) => {
+                const processed = parseJsonResult(result);
+                return typeof onFulfilled === 'function' ? onFulfilled(processed) : processed;
+            },
+            (reason: unknown) => {
+                if (isDeadlock(reason)) options.onDeadlock?.(reason);
+                if (typeof onRejected === 'function') return onRejected(reason);
+                throw reason;
+            },
+        );
+
+    return builder;
+}
+
+/**
+ * Intercept the `then` rejection path of a thenable (e.g. a knex `Raw` result)
+ * so MySQL deadlocks are reported via `options.onDeadlock`. Mirrors the
+ * rejection interception in {@link wrapJsonBuilder} without the JSON column
+ * handling, which does not apply to `raw` queries / stored-procedure calls.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function attachDeadlockHook(thenable: any, options: WrapKnexOptions): any {
+    const originalThen = thenable.then.bind(thenable);
+    thenable.then = (
+        onFulfilled?: ((value: unknown) => unknown) | null,
+        onRejected?: ((reason: unknown) => unknown) | null,
+    ) =>
+        originalThen(onFulfilled, (reason: unknown) => {
+            if (isDeadlock(reason)) options.onDeadlock?.(reason);
+            if (typeof onRejected === 'function') return onRejected(reason);
+            throw reason;
+        });
+    return thenable;
+}
+
+/**
+ * Wrap the shared knex instance so every query path is deadlock-aware (and
+ * `knex('table')` builders are JSON-column aware):
+ *   - `knex('table')`     → {@link wrapJsonBuilder} (JSON columns + deadlock hook)
+ *   - `knex.raw(...)`      → deadlock hook (covers stored-procedure `CALL` + SQL)
+ *   - `knex.transaction()` → the returned `trx` is wrapped like the top-level
+ *     knex, so queries inside transactions are JSON-aware and deadlock-aware.
+ * All other knex surface (`.fn`, `.client`, `.schema`, ...) is left untouched
+ * via the default Proxy get behaviour.
+ *
+ * The parameter is intentionally unconstrained: the installed `knex` types and
+ * the `Knex` re-exported by `@feasibleone/blong` are structurally different, so
+ * callers cast the result with `as unknown as Knex`.
+ */
+export function wrapKnex<T>(knex: T, options: WrapKnexOptions = {}): T {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return new Proxy(knex as any, {
+        apply(target, thisArg, args) {
+            return wrapJsonBuilder(Reflect.apply(target, thisArg, args), options);
+        },
+        get(target, prop, receiver) {
+            if (typeof prop !== 'string') return Reflect.get(target, prop, receiver);
+            if (prop === 'raw') {
+                const original = Reflect.get(target, prop, target);
+                if (typeof original !== 'function') return original;
+                const bound = original.bind(target);
+                return (...args: unknown[]) => attachDeadlockHook(bound(...args), options);
+            }
+            if (prop === 'transaction') {
+                const original = Reflect.get(target, prop, target);
+                if (typeof original !== 'function') return original;
+                const bound = original.bind(target);
+                return (...args: unknown[]) => {
+                    const cbIndex = args.findIndex(arg => typeof arg === 'function');
+                    if (cbIndex !== -1) {
+                        const cb = args[cbIndex] as (trx: unknown) => unknown;
+                        const nextArgs = [...args];
+                        nextArgs[cbIndex] = (trx: unknown) => cb(wrapKnex(trx, options));
+                        return bound(...nextArgs);
+                    }
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const result = bound(...args) as any;
+                    return typeof result?.then === 'function'
+                        ? result.then((trx: unknown) => wrapKnex(trx, options))
+                        : result;
+                };
+            }
+            return Reflect.get(target, prop, receiver);
+        },
+    });
+}

package/src/adapter/schema/knex/schemaMysql.ts

@@ -1,6 +1,5 @@
 import {type Knex} from '@feasibleone/blong/types';
 import {Type, type TFunction, type TSchema} from 'typebox';
-import {attachHandlers} from './schemaTable.ts';
 import {
     extractProcedureBody,
     methodId,
@@ -181,28 +180,3 @@ export async function bindSyntheticHandlers(
         self[camelName] = callable;
     }
 }
-
-/**
- * Bind CRUD synthetic handlers for every table in `tables`, keyed by namespace.
- * Called from `ready()` when `config.namespace` is set.
- */
-export async function bindSyntheticCrud(
-    self: Record<string, unknown>,
-    knex: Knex,
-    namespace: string,
-    tables: Array<{tableName: string; definition: import('typebox').TObject}>,
-): Promise<void> {
-    const {schemaCrudBindImpl} = await import('./schemaTable.ts');
-    for (const {tableName, definition} of tables) {
-        const objectName = snakeToCamel(tableName);
-        const {handlers} = await schemaCrudBindImpl(
-            knex,
-            namespace,
-            objectName,
-            definition,
-            [],
-            tableName,
-        );
-        attachHandlers(self, handlers);
-    }
-}

package/src/adapter/schema/knex/schemaTable.ts

@@ -1,7 +1,7 @@
 import {type Knex} from '@feasibleone/blong/types';
-import {Type, type TFunction, type TObject, type TSchema} from 'typebox';
+import {type TObject} from 'typebox';
 import {type IColumnSchema, type ITableConstraints} from './types.ts';
-import {addColumn, capitalize, methodId} from './utils.ts';
+import {addColumn, methodId} from './utils.ts';
 
 /**
  * Create or synchronise a database table from a TypeBox `TObject` schema.
@@ -86,11 +86,13 @@ export async function schemaTableConstraintSyncImpl(
     const existingConstraints = (
         await knex('information_schema.TABLE_CONSTRAINTS').select('CONSTRAINT_NAME').where({
             TABLE_SCHEMA: knex.client.database(),
+            TABLE_NAME: tableName,
         })
     ).map(c => (c.CONSTRAINT_NAME === 'PRIMARY' ? `${tableName}_pk` : c.CONSTRAINT_NAME));
     const existingIndexes = (
         await knex('information_schema.STATISTICS').select('INDEX_NAME').where({
             TABLE_SCHEMA: knex.client.database(),
+            TABLE_NAME: tableName,
         })
     ).map(i => i.INDEX_NAME);
 
@@ -147,142 +149,6 @@ export async function schemaTableConstraintSyncImpl(
     });
 }
 
-/**
- * Generate CRUD handler functions and their TypeBox schemas for a given table.
- *
- * The returned `handlers` map can be called directly or stored as synthetic
- * handlers on the adapter object.  Operations already listed in
- * `existingHandlers` are skipped so realm-defined handlers take precedence.
- */
-export async function schemaCrudBindImpl(
-    knex: Knex,
-    subject: string,
-    objectName: string,
-    schema: TObject,
-    existingHandlers: string[] = [],
-    tableName?: string,
-): Promise<{
-    handlers: Record<string, (params: Record<string, unknown>) => Promise<unknown>>;
-    schemas: Record<string, TFunction>;
-}> {
-    const existing = new Set(existingHandlers);
-    const table = tableName ?? objectName;
-    const objectId = `${objectName}Id`;
-    const objectCapitalized = capitalize(objectName);
-    const handlers: Record<string, (params: Record<string, unknown>) => Promise<unknown>> = {};
-    const schemas: Record<string, TFunction> = {};
-    const required = new Set(schema.required ?? []);
-    const idSchema = (schema.properties[objectId] as TSchema) ?? Type.String();
-    const entitySchema = Type.Object(
-        Object.fromEntries(Object.entries(schema.properties).map(([k, v]) => [k, v as TSchema])),
-    );
-    const allOptionalProps: Record<string, TSchema> = {};
-    for (const [name, prop] of Object.entries(schema.properties))
-        allOptionalProps[name] = Type.Optional(prop as TSchema);
-    const addProps: Record<string, TSchema> = {};
-    for (const [name, prop] of Object.entries(schema.properties)) {
-        if (name === objectId && (prop as IColumnSchema).type === 'integer') continue;
-        addProps[name] =
-            required.has(name) && name !== objectId
-                ? (prop as TSchema)
-                : Type.Optional(prop as TSchema);
-    }
-
-    const getName = `${subject}${objectCapitalized}Get`;
-    if (!existing.has(getName)) {
-        handlers[getName] = async (params: Record<string, unknown>) => {
-            const {select = '*', ...where} = params;
-            return knex(table)
-                .where(where)
-                .first(select as string);
-        };
-        schemas[getName] = Type.Function(
-            [Type.Object({[objectId]: idSchema})],
-            Type.Promise(entitySchema),
-        );
-    }
-
-    const findName = `${subject}${objectCapitalized}Find`;
-    if (!existing.has(findName)) {
-        handlers[findName] = async (params: Record<string, unknown>) => {
-            const {select = '*', order, limit, offset, ...where} = params;
-            let query = knex(table).where(where);
-            if (order) query = query.orderBy(order as string);
-            if (limit) query = query.limit(limit as number);
-            if (offset) query = query.offset(offset as number);
-            return query.select(select as string);
-        };
-        schemas[findName] = Type.Function(
-            [
-                Type.Object({
-                    ...allOptionalProps,
-                    select: Type.Optional(Type.String()),
-                    order: Type.Optional(Type.String()),
-                    limit: Type.Optional(Type.Integer()),
-                    offset: Type.Optional(Type.Integer()),
-                }),
-            ],
-            Type.Promise(Type.Array(entitySchema)),
-        );
-    }
-
-    const addName = `${subject}${objectCapitalized}Add`;
-    if (!existing.has(addName)) {
-        handlers[addName] = async (params: Record<string, unknown>) => ({
-            [objectId]: (await knex(table).insert(params))?.[0],
-        });
-        schemas[addName] = Type.Function(
-            [Type.Object(addProps)],
-            Type.Promise(Type.Object({[objectId]: idSchema})),
-        );
-    }
-
-    const editName = `${subject}${objectCapitalized}Edit`;
-    if (!existing.has(editName)) {
-        handlers[editName] = async (params: Record<string, unknown>) => {
-            const {key: keyName = objectId, ...columns} = params;
-            const {[keyName as string]: key, ...update} = columns;
-            return knex(table)
-                .where({[keyName as string]: key})
-                .update(update);
-        };
-        schemas[editName] = Type.Function(
-            [Type.Object({[objectId]: idSchema, ...allOptionalProps})],
-            Type.Promise(Type.Integer({description: 'Number of affected rows'})),
-        );
-    }
-
-    const removeName = `${subject}${objectCapitalized}Remove`;
-    if (!existing.has(removeName)) {
-        handlers[removeName] = async (params: Record<string, unknown>) =>
-            knex(table)
-                .where({[objectId]: params[objectId]})
-                .del();
-        schemas[removeName] = Type.Function(
-            [Type.Object({[objectId]: idSchema})],
-            Type.Promise(Type.Integer({description: 'Number of affected rows'})),
-        );
-    }
-
-    const mergeName = `${subject}${objectCapitalized}Merge`;
-    if (!existing.has(mergeName)) {
-        handlers[mergeName] = async (params: Record<string, unknown>) =>
-            knex(table).insert(params).onConflict(objectId).merge();
-        schemas[mergeName] = Type.Function(
-            [
-                Type.Object(
-                    Object.fromEntries(
-                        Object.entries(schema.properties).map(([k, v]) => [k, v as TSchema]),
-                    ),
-                ),
-            ],
-            Type.Promise(Type.Unknown()),
-        );
-    }
-
-    return {handlers, schemas};
-}
-
 /**
  * Store each handler from `handlersMap` on `self` under two keys so it can be
  * reached via both framework dispatch and `super` calls: