tina4-nodejs 3.13.43 → 3.13.45

package/packages/core/src/sessionHandlers/valkeyHandler.ts

@@ -11,8 +11,8 @@
  *   TINA4_SESSION_VALKEY_PREFIX   (default: "tina4:session:")
  *   TINA4_SESSION_VALKEY_DB       (default: 0)
  */
-import { execFileSync } from "node:child_process";
 import type { SessionHandler } from "../session.js";
+import { respCommandSync } from "./respClient.js";
 
 interface SessionData {
   _created: number;
@@ -75,103 +75,19 @@ export class ValkeySessionHandler implements SessionHandler {
   }
 
   /**
-   * Execute a RESP command synchronously via a short-lived TCP connection.
+   * Execute a RESP command synchronously against the live Valkey server.
    *
-   * Returns the command result string. A genuine key miss yields `""`. A
-   * transport/connection FAILURE (server unreachable, AUTH error, timeout)
-   * THROWS so the Session boundary can distinguish "not found" (silent) from
-   * "backend failed" (log-loud + degrade). Backend-failure policy parity.
+   * Delegates to the shared {@link respCommandSync} transport: a genuine key miss
+   * yields `""`, and a transport/connection FAILURE (server unreachable, rejected
+   * AUTH, timeout) THROWS so the Session boundary can distinguish "not found"
+   * (silent) from "backend failed" (log-loud + degrade). Backend-failure parity.
    */
   private execSync(args: string[]): string {
-    const script = `
-      const net = require("node:net");
-      const host = ${JSON.stringify(this.host)};
-      const port = ${this.port};
-      const password = ${JSON.stringify(this.password)};
-      const db = ${this.db};
-      const args = ${JSON.stringify(args)};
-
-      function buildCommand(a) {
-        let cmd = "*" + a.length + "\\r\\n";
-        for (const s of a) cmd += "$" + Buffer.byteLength(s) + "\\r\\n" + s + "\\r\\n";
-        return cmd;
-      }
-
-      function parseResp(buf) {
-        const str = buf.toString("utf-8");
-        if (str.startsWith("+")) return str.slice(1).split("\\r\\n")[0];
-        if (str.startsWith("-")) return "ERR:" + str.slice(1).split("\\r\\n")[0];
-        if (str.startsWith(":")) return str.slice(1).split("\\r\\n")[0];
-        if (str.startsWith("$-1")) return null;
-        if (str.startsWith("$")) {
-          const nl = str.indexOf("\\r\\n");
-          const len = parseInt(str.slice(1, nl), 10);
-          const start = nl + 2;
-          return str.slice(start, start + len);
-        }
-        return str;
-      }
-
-      const sock = net.createConnection({ host, port }, () => {
-        let commands = "";
-        if (password) commands += buildCommand(["AUTH", password]);
-        if (db !== 0) commands += buildCommand(["SELECT", String(db)]);
-        commands += buildCommand(args);
-        sock.write(commands);
-      });
-
-      let buffer = Buffer.alloc(0);
-      sock.on("data", (chunk) => {
-        buffer = Buffer.concat([buffer, chunk]);
-      });
-      sock.on("end", () => {
-        // Parse last response (skip AUTH/SELECT responses)
-        const lines = buffer.toString("utf-8").split("\\r\\n");
-        let responses = [];
-        let i = 0;
-        while (i < lines.length) {
-          const line = lines[i];
-          if (!line) { i++; continue; }
-          if (line.startsWith("+") || line.startsWith("-") || line.startsWith(":")) {
-            responses.push(line);
-            i++;
-          } else if (line.startsWith("$")) {
-            const len = parseInt(line.slice(1), 10);
-            if (len === -1) { responses.push(null); i++; }
-            else { responses.push(lines[i+1] || ""); i += 2; }
-          } else { i++; }
-        }
-        // The last response is our actual command result
-        const result = responses[responses.length - 1];
-        if (result === null) process.stdout.write("__NULL__");
-        else if (typeof result === "string" && result.startsWith("-")) process.stdout.write("__ERR__" + result);
-        else process.stdout.write(String(result ?? "__NULL__"));
-      });
-      sock.on("error", (err) => {
-        process.stderr.write(err.message);
-        process.exit(1);
-      });
-      setTimeout(() => { sock.destroy(); process.exit(1); }, 3000);
-    `;
-
-    let result: string;
-    try {
-      result = execFileSync(process.execPath, ["-e", script], {
-        encoding: "utf-8",
-        timeout: 5000,
-        stdio: ["pipe", "pipe", "pipe"],
-      });
-    } catch (err) {
-      // Non-zero exit = the child hit a socket error / AUTH failure / timeout.
-      // That is a transport FAILURE, not a key miss — surface it so the
-      // Session boundary logs + degrades (or re-throws under strict mode).
-      throw new Error(`Valkey command failed: ${(err as Error).message}`);
-    }
-    if (result === "__NULL__") return "";        // genuine key miss
-    if (result.startsWith("__ERR__")) {
-      throw new Error(`Valkey error: ${result.slice("__ERR__".length)}`);
-    }
-    return result;
+    return respCommandSync(
+      { host: this.host, port: this.port, password: this.password, db: this.db },
+      args,
+      "Valkey",
+    );
   }
 
   private key(sessionId: string): string {

package/packages/orm/src/adapters/firebird.ts

@@ -278,12 +278,30 @@ export class FirebirdAdapter implements DatabaseAdapter {
     return rows[0] ?? null;
   }
 
-  insert(table: string, data: Record<string, unknown>): DatabaseResult {
+  insert(table: string, data: Record<string, unknown> | Record<string, unknown>[]): DatabaseResult {
     throw new Error("Use insertAsync() for Firebird.");
   }
 
-  async insertAsync(table: string, data: Record<string, unknown>): Promise<DatabaseResult> {
+  async insertAsync(table: string, data: Record<string, unknown> | Record<string, unknown>[]): Promise<DatabaseResult> {
     this.ensureConnected();
+    // A list of dicts is a batch insert — one parameterised INSERT run per row via
+    // executeManyAsync (ONE connection). Firebird has no generic last_insert_id, so
+    // the batch reports affectedRows == row count and no lastInsertId (same as the
+    // single-row path). See PostgresAdapter for the array-crash rationale.
+    if (Array.isArray(data)) {
+      if (data.length === 0) return { success: true, rowsAffected: 0 };
+      const keys = Object.keys(data[0]);
+      const placeholders = keys.map(() => "?").join(", ");
+      const sql = `INSERT INTO "${table}" ("${keys.join('", "')}") VALUES (${placeholders})`;
+      const paramsList = data.map((row) => keys.map((k) => row[k]));
+      try {
+        const result = await this.executeManyAsync(sql, paramsList);
+        return { success: true, rowsAffected: result.totalAffected, lastInsertId: result.lastInsertId };
+      } catch (e) {
+        return { success: false, rowsAffected: 0, error: (e as Error).message };
+      }
+    }
+
     const keys = Object.keys(data);
     const placeholders = keys.map(() => "?").join(", ");
     const sql = `INSERT INTO "${table}" ("${keys.join('", "')}") VALUES (${placeholders})`;

package/packages/orm/src/adapters/mssql.ts

@@ -236,12 +236,34 @@ export class MssqlAdapter implements DatabaseAdapter {
     return rows[0] ?? null;
   }
 
-  insert(table: string, data: Record<string, unknown>): DatabaseResult {
+  insert(table: string, data: Record<string, unknown> | Record<string, unknown>[]): DatabaseResult {
     throw new Error("Use insertAsync() for MSSQL.");
   }
 
-  async insertAsync(table: string, data: Record<string, unknown>): Promise<DatabaseResult> {
+  async insertAsync(table: string, data: Record<string, unknown> | Record<string, unknown>[]): Promise<DatabaseResult> {
     this.ensureConnected();
+    // A list of dicts is a batch insert — one parameterised INSERT run per row via
+    // executeManyAsync (ONE connection). The single-row path appends SELECT
+    // SCOPE_IDENTITY() to surface the id; the batch path omits it (no per-row id is
+    // tracked for a batch — affectedRows == row count is what callers rely on).
+    // See PostgresAdapter for the array-crash rationale this branch fixes.
+    if (Array.isArray(data)) {
+      if (data.length === 0) return { success: true, rowsAffected: 0 };
+      const keys = Object.keys(data[0]);
+      // `?` placeholders — executeManyAsync -> executeAsync runs convertPlaceholders,
+      // which rewrites them to @p0, @p1, ... for tedious.
+      const placeholders = keys.map(() => "?").join(", ");
+      const sql = `INSERT INTO [${table}] ([${keys.join("], [")}]) VALUES (${placeholders})`;
+      const paramsList = data.map((row) => keys.map((k) => row[k]));
+      try {
+        const result = await this.executeManyAsync(sql, paramsList);
+        if (result.lastInsertId !== undefined) this._lastInsertId = result.lastInsertId;
+        return { success: true, rowsAffected: result.totalAffected, lastInsertId: result.lastInsertId };
+      } catch (e) {
+        return { success: false, rowsAffected: 0, error: (e as Error).message };
+      }
+    }
+
     const keys = Object.keys(data);
     const placeholders = keys.map((_, i) => `@p${i}`).join(", ");
     const sql = `INSERT INTO [${table}] ([${keys.join("], [")}]) VALUES (${placeholders}); SELECT SCOPE_IDENTITY() AS id`;

package/packages/orm/src/adapters/mysql.ts

@@ -163,12 +163,30 @@ export class MysqlAdapter implements DatabaseAdapter {
     return rows[0] ?? null;
   }
 
-  insert(table: string, data: Record<string, unknown>): DatabaseResult {
+  insert(table: string, data: Record<string, unknown> | Record<string, unknown>[]): DatabaseResult {
     throw new Error("Use insertAsync() for MySQL.");
   }
 
-  async insertAsync(table: string, data: Record<string, unknown>): Promise<DatabaseResult> {
+  async insertAsync(table: string, data: Record<string, unknown> | Record<string, unknown>[]): Promise<DatabaseResult> {
     this.ensureConnected();
+    // A list of dicts is a batch insert — one parameterised INSERT run per row via
+    // executeManyAsync (ONE connection). See PostgresAdapter for the rationale;
+    // without this branch a list crashed/mis-built SQL via Object.keys() on the array.
+    if (Array.isArray(data)) {
+      if (data.length === 0) return { success: true, rowsAffected: 0 };
+      const keys = Object.keys(data[0]);
+      const placeholders = keys.map(() => "?").join(", ");
+      const sql = `INSERT INTO \`${table}\` (\`${keys.join("`, `")}\`) VALUES (${placeholders})`;
+      const paramsList = data.map((row) => keys.map((k) => row[k]));
+      try {
+        const result = await this.executeManyAsync(sql, paramsList);
+        if (result.lastInsertId !== undefined) this._lastInsertId = result.lastInsertId;
+        return { success: true, rowsAffected: result.totalAffected, lastInsertId: result.lastInsertId };
+      } catch (e) {
+        return { success: false, rowsAffected: 0, error: (e as Error).message };
+      }
+    }
+
     const keys = Object.keys(data);
     const placeholders = keys.map(() => "?").join(", ");
     const sql = `INSERT INTO \`${table}\` (\`${keys.join("`, `")}\`) VALUES (${placeholders})`;

package/packages/orm/src/adapters/postgres.ts

@@ -68,7 +68,10 @@ export interface PostgresConfig {
 
 export class PostgresAdapter implements DatabaseAdapter {
   private client: InstanceType<typeof import("pg").Client> | null = null;
-  private _lastInsertId: number | bigint | null = null;
+  // string is included for non-integer primary keys: a UUID PK (the common
+  // `id uuid PRIMARY KEY DEFAULT gen_random_uuid()` shape) returns its id as a
+  // 36-char string via RETURNING, not a SERIAL integer (#256).
+  private _lastInsertId: number | bigint | string | null = null;
 
   constructor(private config: PostgresConfig | string) {}
 
@@ -115,16 +118,20 @@ export class PostgresAdapter implements DatabaseAdapter {
 
   /**
    * Normalise an `id` column value (typed `unknown` because pg row values are
-   * `unknown`) into the `number | bigint | null` shape `_lastInsertId` /
-   * `DatabaseResult.lastInsertId` expect. At runtime PG returns numeric PKs as
-   * number/bigint (the int8/numeric type parsers above coerce them to Number);
-   * a numeric string is coerced, anything else (null/undefined/non-numeric)
-   * becomes null.
+   * `unknown`) into the shape `_lastInsertId` / `DatabaseResult.lastInsertId`
+   * expect. At runtime PG returns numeric PKs as number/bigint (the int8/numeric
+   * type parsers above coerce them to Number); a numeric string is coerced to a
+   * number so the SERIAL path always returns the integer id.
+   *
+   * A non-numeric string id — the UUID PK case (`id uuid PRIMARY KEY DEFAULT
+   * gen_random_uuid()`) returned via RETURNING — is preserved as-is so the
+   * insert surfaces the actual id instead of null (#256). null/undefined/empty
+   * still become null.
    */
-  private normalizeId(value: unknown): number | bigint | null {
+  private normalizeId(value: unknown): number | bigint | string | null {
     if (typeof value === "number" || typeof value === "bigint") return value;
-    if (typeof value === "string" && value.trim() !== "" && !Number.isNaN(Number(value))) {
-      return Number(value);
+    if (typeof value === "string" && value.trim() !== "") {
+      return Number.isNaN(Number(value)) ? value : Number(value);
     }
     return null;
   }
@@ -202,12 +209,33 @@ export class PostgresAdapter implements DatabaseAdapter {
     return rows[0] ?? null;
   }
 
-  insert(table: string, data: Record<string, unknown>): DatabaseResult {
+  insert(table: string, data: Record<string, unknown> | Record<string, unknown>[]): DatabaseResult {
     throw new Error("Use insertAsync() for PostgreSQL.");
   }
 
-  async insertAsync(table: string, data: Record<string, unknown>): Promise<DatabaseResult> {
+  async insertAsync(table: string, data: Record<string, unknown> | Record<string, unknown>[]): Promise<DatabaseResult> {
     this.ensureConnected();
+    // A list of dicts is a batch insert — build one parameterised INSERT and run
+    // it once per row via executeManyAsync (ONE connection, wrapped in a single
+    // transaction). Database.insert / the docs advertise `data: object | object[]`;
+    // without this branch a list called Object.keys() on the array — `["0","1",…]`
+    // — producing garbage SQL (mirrors the Python `'list' has no attribute keys`
+    // crash this fix addresses).
+    if (Array.isArray(data)) {
+      if (data.length === 0) return { success: true, rowsAffected: 0 };
+      const keys = Object.keys(data[0]);
+      const placeholders = keys.map(() => "?").join(", ");
+      const sql = `INSERT INTO "${table}" ("${keys.join('", "')}") VALUES (${placeholders})`;
+      const paramsList = data.map((row) => keys.map((k) => row[k]));
+      try {
+        const result = await this.executeManyAsync(sql, paramsList);
+        if (result.lastInsertId !== undefined) this._lastInsertId = result.lastInsertId;
+        return { success: true, rowsAffected: result.totalAffected, lastInsertId: result.lastInsertId };
+      } catch (e) {
+        return { success: false, rowsAffected: 0, error: (e as Error).message };
+      }
+    }
+
     const keys = Object.keys(data);
     const placeholders = keys.map((_, i) => `$${i + 1}`).join(", ");
     const sql = `INSERT INTO "${table}" ("${keys.join('", "')}") VALUES (${placeholders}) RETURNING *`;
@@ -337,7 +365,7 @@ export class PostgresAdapter implements DatabaseAdapter {
     }));
   }
 
-  lastInsertId(): number | bigint | null {
+  lastInsertId(): number | bigint | string | null {
     return this._lastInsertId;
   }
 

package/packages/orm/src/adapters/sqlite.ts

@@ -18,9 +18,23 @@ function isIdentifier(str: string): boolean {
  */
 type SqlParam = null | number | bigint | string | NodeJS.ArrayBufferView;
 
-/** Narrow adapter-level `unknown[]` params to node:sqlite's bindable type. */
+/**
+ * Coerce adapter-level `unknown[]` params to node:sqlite's bindable shape.
+ *
+ * node:sqlite only binds null/number/bigint/string/ArrayBufferView and REJECTS a
+ * raw JS boolean ("Provided value cannot be bound to SQLite parameter N"). SQLite
+ * stores booleans as INTEGER 0/1 (fieldTypeToSQLite maps "boolean" -> INTEGER, and
+ * boolean defaults already emit 1/0), so coerce here at the single bind boundary —
+ * every write path (execute/query/fetchOne/insert/update/delete and ORM save())
+ * funnels through this. booleans -> 0/1, Date -> ISO-8601 string, undefined -> null.
+ */
 function toSqlParams(params: readonly unknown[]): SqlParam[] {
-  return params as SqlParam[];
+  return params.map((p) => {
+    if (typeof p === "boolean") return p ? 1 : 0;
+    if (p === undefined) return null;
+    if (p instanceof Date) return p.toISOString();
+    return p as SqlParam;
+  });
 }
 
 /**

package/packages/orm/src/autoCrud.ts

@@ -64,6 +64,19 @@ export class AutoCrud {
   }
 }
 
+/**
+ * Filter discovered models down to those that explicitly opted into auto-CRUD via
+ * `static autoCrud = true` (the documented opt-in gate; default false). The server
+ * passes only these to generateCrudRoutes, so a model without the flag gets no CRUD
+ * endpoints. Exported so the opt-in gate is locked in by a test rather than
+ * re-implemented at each call site.
+ */
+export function crudEligibleModels(models: DiscoveredModel[]): DiscoveredModel[] {
+  return models.filter(
+    (m) => (m.modelClass as { autoCrud?: boolean } | undefined)?.autoCrud === true,
+  );
+}
+
 /**
  * Generate CRUD route definitions for the given models.
  * (Standalone function for backward compatibility.)

package/packages/orm/src/baseModel.ts

@@ -679,7 +679,9 @@ export class BaseModel {
         // the caller; don't overwrite it with the driver's last_id.
         if (pkField?.autoIncrement) {
           // RETURNING result: pg puts it in rows[0][pkCol]; normalise here.
-          let newId = extractLastInsertId(result);
+          // string is allowed for a non-integer PK surfaced by lastInsertId()
+          // (e.g. a PostgreSQL UUID PK) — #256.
+          let newId: number | bigint | string | null = extractLastInsertId(result);
           if (newId === null && result && typeof result === "object") {
             const rows = (result as any).rows;
             if (Array.isArray(rows) && rows[0]) {

package/packages/orm/src/cachedDatabase.ts

@@ -397,7 +397,7 @@ export class CachedDatabaseAdapter implements DatabaseAdapter {
     return this.adapter.columns(table);
   }
 
-  lastInsertId(): number | bigint | null {
+  lastInsertId(): number | bigint | string | null {
     return this.adapter.lastInsertId();
   }
 

package/packages/orm/src/database.ts

@@ -519,6 +519,19 @@ export class Database {
     this.adapter = adapter;
   }
 
+  /**
+   * Set the engine type ("sqlite" | "postgres" | "mysql" | "mssql" |
+   * "firebird" | "mongodb"). The static `Database.create` factory assigns the
+   * private `dbType` directly; `initDatabase()` (a free function, no private
+   * access) routes through this setter so a URL connection is correctly typed.
+   * Without it a `postgres://` connection kept the `"sqlite"` default and
+   * `getNextId()` took the SQLite branch — hitting the non-existent
+   * `tina4_sequences` table on PostgreSQL instead of native sequences (#255).
+   */
+  setDbType(type: string): void {
+    this.dbType = type;
+  }
+
   /**
    * Async factory: creates a Database from a connection URL.
    * Works with all adapter types (sqlite, postgres, mysql, mssql, firebird).
@@ -755,8 +768,8 @@ export class Database {
     }
   }
 
-  /** Insert a row into a table. */
-  async insert(table: string, data: Record<string, unknown>): Promise<DatabaseWriteResult> {
+  /** Insert one row (object) or a batch of rows (array of objects) into a table. */
+  async insert(table: string, data: Record<string, unknown> | Record<string, unknown>[]): Promise<DatabaseWriteResult> {
     const adapter = this.getNextAdapter();
     const result = (adapter as any).insertAsync
       ? await (adapter as any).insertAsync(table, data)
@@ -1434,11 +1447,19 @@ export async function initDatabase(config?: DatabaseConfig): Promise<Database> {
     if (pool > 0) {
       // Pool-aware path — delegate to Database.create which manages
       // round-robin adapter rotation and async-local-storage transaction pinning.
-      // Database.create already exposes the global; exposeDb here is idempotent.
+      // Database.create already sets dbType + exposes the global; exposeDb here
+      // is idempotent.
       return exposeDb(await Database.create(url, resolvedUser, resolvedPassword, pool));
     }
+    // Single-connection URL path. Parse the URL so the engine type is known and
+    // set it on the Database — otherwise dbType keeps its "sqlite" default and a
+    // postgres://… connection takes the SQLite getNextId branch, crashing on the
+    // missing tina4_sequences table instead of using native sequences (#255).
+    const parsed = parseDatabaseUrl(url, resolvedUser, resolvedPassword);
     const adapter = await createAdapterFromUrl(url, resolvedUser, resolvedPassword);
-    return exposeDb(new Database(setAdapter(adapter)));
+    const db = new Database(setAdapter(adapter));
+    db.setDbType(parsed.type);
+    return exposeDb(db);
   }
 
   // Legacy config path — normalize "sqlserver" to "mssql"
@@ -1459,11 +1480,21 @@ export async function initDatabase(config?: DatabaseConfig): Promise<Database> {
     );
   }
 
+  // Legacy config-object path. As with the URL path above, the constructed
+  // Database must be told its engine type — otherwise dbType keeps its "sqlite"
+  // default and a `{ type: "postgres" }` connection takes the SQLite getNextId
+  // branch and crashes on the missing tina4_sequences table (#255).
+  const finished = (adapter: DatabaseAdapter): Database => {
+    const db = new Database(setAdapter(adapter));
+    db.setDbType(type);
+    return exposeDb(db);
+  };
+
   switch (type) {
     case "sqlite": {
       const { SQLiteAdapter } = await import("./adapters/sqlite.js");
       const adapter = new SQLiteAdapter(config?.path ?? "./data/tina4.db");
-      return exposeDb(new Database(setAdapter(adapter)));
+      return finished(adapter);
     }
     case "postgres": {
       const { PostgresAdapter } = await import("./adapters/postgres.js");
@@ -1475,7 +1506,7 @@ export async function initDatabase(config?: DatabaseConfig): Promise<Database> {
         database: config?.database,
       });
       await adapter.connect();
-      return exposeDb(new Database(setAdapter(adapter)));
+      return finished(adapter);
     }
     case "mysql": {
       const { MysqlAdapter } = await import("./adapters/mysql.js");
@@ -1487,7 +1518,7 @@ export async function initDatabase(config?: DatabaseConfig): Promise<Database> {
         database: config?.database,
       });
       await adapter.connect();
-      return exposeDb(new Database(setAdapter(adapter)));
+      return finished(adapter);
     }
     case "mssql": {
       const { MssqlAdapter } = await import("./adapters/mssql.js");
@@ -1499,7 +1530,7 @@ export async function initDatabase(config?: DatabaseConfig): Promise<Database> {
         database: config?.database,
       });
       await adapter.connect();
-      return exposeDb(new Database(setAdapter(adapter)));
+      return finished(adapter);
     }
     case "firebird": {
       const { FirebirdAdapter } = await import("./adapters/firebird.js");
@@ -1511,7 +1542,7 @@ export async function initDatabase(config?: DatabaseConfig): Promise<Database> {
         database: config?.database,
       });
       await adapter.connect();
-      return exposeDb(new Database(setAdapter(adapter)));
+      return finished(adapter);
     }
     case "mongodb": {
       const { MongodbAdapter } = await import("./adapters/mongodb.js");
@@ -1524,14 +1555,14 @@ export async function initDatabase(config?: DatabaseConfig): Promise<Database> {
       const connectionString = `mongodb://${creds}${host}:${port}/${database}`;
       const adapter = new MongodbAdapter(connectionString);
       await adapter.connect();
-      return exposeDb(new Database(setAdapter(adapter)));
+      return finished(adapter);
     }
     case "odbc": {
       const { OdbcAdapter } = await import("./adapters/odbc.js");
       const connStr = config?.connectionString ?? config?.url?.replace(/^odbc:\/\/\//, "") ?? "";
       const adapter = new OdbcAdapter({ connectionString: connStr });
       await adapter.connect();
-      return exposeDb(new Database(setAdapter(adapter)));
+      return finished(adapter);
     }
     default:
       throw new Error(`Unknown database type: ${type}`);

package/packages/orm/src/index.ts

@@ -45,7 +45,7 @@ export {
   shouldSkipCreateTable,
 } from "./migration.js";
 export type { MigrationResult, MigrationStatus } from "./migration.js";
-export { AutoCrud, generateCrudRoutes } from "./autoCrud.js";
+export { AutoCrud, generateCrudRoutes, crudEligibleModels } from "./autoCrud.js";
 export { buildQuery, parseQueryString } from "./query.js";
 export { validate } from "./validation.js";
 export type { ValidationError } from "./validation.js";