@metaobjectsdev/runtime-ts 0.5.0-rc.1

package/src/drivers/in-memory-driver.ts

@@ -0,0 +1,256 @@
+import type {
+  PersistenceDriver, SelectSpec, CountSpec, InsertSpec, InsertManySpec,
+  UpdateSpec, UpdateManySpec, DeleteSpec, DeleteManySpec, WhereClause, Row,
+} from "../persistence-driver.js";
+import { ConstraintViolationError } from "../errors.js";
+
+export interface InMemoryDriverOptions {
+  /** Initial table data: { tableName: Row[] }. */
+  seed?: Record<string, Row[]>;
+  /** Per-table PK field names (used to detect collisions + auto-increment). Default: ["id"]. */
+  pkFields?: Record<string, string[]>;
+  /** Auto-increment counter starting value per table. Default: 1 + max existing PK. */
+  startCounters?: Record<string, number>;
+}
+
+interface State {
+  // Outer key: table name. Inner key: pk values joined by REF_PK_SEPARATOR (",").
+  tables: Map<string, Map<string, Row>>;
+  pkFields: Map<string, string[]>;
+  counters: Map<string, number>;
+}
+
+export function inMemoryDriver(opts: InMemoryDriverOptions = {}): PersistenceDriver {
+  const state = createState(opts);
+  return makeDriver(state);
+}
+
+function createState(opts: InMemoryDriverOptions): State {
+  const tables = new Map<string, Map<string, Row>>();
+  const pkFields = new Map<string, string[]>();
+  const counters = new Map<string, number>();
+
+  for (const [tableName, rows] of Object.entries(opts.seed ?? {})) {
+    const pk = opts.pkFields?.[tableName] ?? ["id"];
+    pkFields.set(tableName, pk);
+    const map = new Map<string, Row>();
+    let maxNumericPk = 0;
+    for (const row of rows) {
+      const key = pkKey(row, pk);
+      map.set(key, structuredClone(row));
+      const v = row[pk[0]!];
+      if (typeof v === "number" && v > maxNumericPk) maxNumericPk = v;
+    }
+    tables.set(tableName, map);
+    counters.set(tableName, opts.startCounters?.[tableName] ?? maxNumericPk + 1);
+  }
+
+  return { tables, pkFields, counters };
+}
+
+function makeDriver(state: State): PersistenceDriver {
+  const ensureTable = (table: string): Map<string, Row> => {
+    let t = state.tables.get(table);
+    if (!t) {
+      t = new Map();
+      state.tables.set(table, t);
+      state.pkFields.set(table, ["id"]);
+      state.counters.set(table, 1);
+    }
+    return t;
+  };
+
+  const ensurePk = (table: string): string[] => {
+    let pk = state.pkFields.get(table);
+    if (!pk) {
+      pk = ["id"];
+      state.pkFields.set(table, pk);
+    }
+    return pk;
+  };
+
+  return {
+    dialect: "memory",
+
+    async selectOne(spec) {
+      const rows = await this.selectMany({ ...spec, limit: 1 });
+      return rows[0] ?? null;
+    },
+
+    async selectMany(spec) {
+      const t = state.tables.get(spec.table);
+      if (!t) return [];
+      let rows = [...t.values()].filter((r) => matchesWhere(r, spec.where));
+      if (spec.orderBy) {
+        for (const ob of [...spec.orderBy].reverse()) {
+          rows.sort((a, b) => compareValues(a[ob.column], b[ob.column]) * (ob.direction === "asc" ? 1 : -1));
+        }
+      }
+      if (spec.offset) rows = rows.slice(spec.offset);
+      if (spec.limit !== undefined) rows = rows.slice(0, spec.limit);
+      return rows.map((r) => projectColumns(r, spec.columns));
+    },
+
+    async count(spec) {
+      const t = state.tables.get(spec.table);
+      if (!t) return 0;
+      return [...t.values()].filter((r) => matchesWhere(r, spec.where)).length;
+    },
+
+    async insert(spec) {
+      const t = ensureTable(spec.table);
+      const pk = ensurePk(spec.table);
+      const row = { ...spec.values };
+      for (const f of pk) {
+        if (row[f] === undefined || row[f] === null) {
+          if (pk.length !== 1) {
+            throw new ConstraintViolationError(
+              `Composite PK requires all values; missing ${f}`, { kind: "not_null", table: spec.table, field: f },
+            );
+          }
+          const next = state.counters.get(spec.table) ?? 1;
+          row[f] = next;
+          state.counters.set(spec.table, next + 1);
+        }
+      }
+      const key = pkKey(row, pk);
+      if (t.has(key)) {
+        throw new ConstraintViolationError(
+          `Unique violation on ${spec.table} PK ${key}`, { kind: "unique", table: spec.table, field: pk[0]! },
+        );
+      }
+      t.set(key, structuredClone(row));
+      return projectColumns(row, spec.returning);
+    },
+
+    async insertMany(spec) {
+      const out: Row[] = [];
+      for (const values of spec.rows) {
+        out.push(await this.insert({ table: spec.table, values, returning: spec.returning }));
+      }
+      return out;
+    },
+
+    async update(spec) {
+      const t = state.tables.get(spec.table);
+      if (!t) return null;
+      const matches = [...t.entries()].filter(([, r]) => matchesWhere(r, spec.where));
+      if (matches.length === 0) return null;
+      const [key, row] = matches[0]!;
+      const updated = { ...row, ...spec.values };
+      t.set(key, structuredClone(updated));
+      return projectColumns(updated, spec.returning);
+    },
+
+    async updateMany(spec) {
+      const t = state.tables.get(spec.table);
+      if (!t) return 0;
+      let n = 0;
+      for (const [key, row] of t.entries()) {
+        if (!matchesWhere(row, spec.where)) continue;
+        t.set(key, structuredClone({ ...row, ...spec.values }));
+        n++;
+      }
+      return n;
+    },
+
+    async delete(spec) {
+      return this.deleteMany(spec);
+    },
+
+    async deleteMany(spec) {
+      const t = state.tables.get(spec.table);
+      if (!t) return 0;
+      const keysToDelete = [...t.entries()].filter(([, r]) => matchesWhere(r, spec.where)).map(([k]) => k);
+      for (const k of keysToDelete) t.delete(k);
+      return keysToDelete.length;
+    },
+
+    async transaction(fn) {
+      const snapshot = snapshotState(state);
+      try {
+        return await fn(this);
+      } catch (err) {
+        restoreState(state, snapshot);
+        throw err;
+      }
+    },
+  };
+}
+
+function projectColumns(row: Row, columns: string[]): Row {
+  if (columns.length === 0) return { ...row };
+  const out: Row = {};
+  for (const c of columns) {
+    if (c in row) out[c] = row[c];
+  }
+  return out;
+}
+
+function pkKey(row: Row, pkFields: string[]): string {
+  return pkFields.map((f) => String(row[f])).join(",");
+}
+
+function matchesWhere(row: Row, where?: WhereClause): boolean {
+  if (!where) return true;
+  switch (where.kind) {
+    case "eq":
+      return row[where.column] === where.value;
+    case "ne":
+      return row[where.column] !== where.value;
+    case "gt":
+      return compareValues(row[where.column], where.value) > 0;
+    case "gte":
+      return compareValues(row[where.column], where.value) >= 0;
+    case "lt":
+      return compareValues(row[where.column], where.value) < 0;
+    case "lte":
+      return compareValues(row[where.column], where.value) <= 0;
+    case "in":
+      return where.values.some((v) => row[where.column] === v);
+    case "like":
+      return likeMatch(row[where.column], where.pattern);
+    case "isNull": {
+      const isNull = row[where.column] === null || row[where.column] === undefined;
+      return where.not ? !isNull : isNull;
+    }
+    case "and":
+      return where.clauses.every((c) => matchesWhere(row, c));
+    default: {
+      const exhaustive: never = where;
+      throw new Error(`Unhandled WhereClause kind: ${JSON.stringify(exhaustive)}`);
+    }
+  }
+}
+
+function compareValues(a: unknown, b: unknown): number {
+  if (a === b) return 0;
+  if (a === null || a === undefined) return -1;
+  if (b === null || b === undefined) return 1;
+  if (typeof a === "number" && typeof b === "number") return a - b;
+  return String(a).localeCompare(String(b));
+}
+
+// SQL LIKE: % → .*, _ → ., case-sensitive. Other regex metacharacters in `pattern` are escaped first.
+function likeMatch(value: unknown, pattern: string): boolean {
+  if (typeof value !== "string") return false;
+  const re = new RegExp("^" + pattern.replace(/[.+*?^${}()|[\]\\]/g, "\\$&").replace(/%/g, ".*").replace(/_/g, ".") + "$");
+  return re.test(value);
+}
+
+function snapshotState(state: State): State {
+  return {
+    tables: new Map([...state.tables.entries()].map(([t, m]) => [t, new Map([...m.entries()].map(([k, r]) => [k, structuredClone(r)]))])),
+    pkFields: new Map(state.pkFields),
+    counters: new Map(state.counters),
+  };
+}
+
+function restoreState(state: State, snapshot: State): void {
+  state.tables.clear();
+  for (const [t, m] of snapshot.tables.entries()) state.tables.set(t, m);
+  state.pkFields.clear();
+  for (const [k, v] of snapshot.pkFields.entries()) state.pkFields.set(k, v);
+  state.counters.clear();
+  for (const [k, v] of snapshot.counters.entries()) state.counters.set(k, v);
+}

package/src/drivers/index.ts

@@ -0,0 +1,3 @@
+export { inMemoryDriver, type InMemoryDriverOptions } from "./in-memory-driver.js";
+export { kyselyDriver, type KyselyDriverOptions, type KyselyDriverPublic } from "./kysely-driver.js";
+export { drizzleDriver, type DrizzleDriverOptions, type DrizzleDriverPublic } from "./drizzle-driver.js";

package/src/drivers/kysely-driver.ts

@@ -0,0 +1,240 @@
+import type { Kysely, ExpressionBuilder, SelectQueryBuilder, Expression, SqlBool } from "kysely";
+import type {
+  PersistenceDriver, SelectSpec, CountSpec, InsertSpec, InsertManySpec,
+  UpdateSpec, UpdateManySpec, DeleteSpec, DeleteManySpec, WhereClause, Row,
+} from "../persistence-driver.js";
+import { ConstraintViolationError } from "../errors.js";
+
+// Kysely's fluent builder is heavily generic on the database schema, but this driver
+// is metadata-driven and accepts any table name at runtime. Confine the schema-agnostic
+// escape to these aliases rather than per-call `as any`.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type RawKysely = Kysely<any>;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyExprBuilder = ExpressionBuilder<any, any>;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyQuery = SelectQueryBuilder<any, any, any>;
+
+export interface KyselyDriverOptions {
+  db: Kysely<Record<string, Row>>;
+  dialect: "sqlite" | "postgres";
+}
+
+export interface KyselyDriverPublic extends PersistenceDriver {
+  /** The underlying Kysely instance — power-user escape hatch. */
+  readonly db: Kysely<Record<string, Row>>;
+}
+
+export function kyselyDriver(opts: KyselyDriverOptions): KyselyDriverPublic {
+  return makeKyselyDriver(opts.db, opts.dialect);
+}
+
+function makeKyselyDriver(
+  db: Kysely<Record<string, Row>>,
+  dialect: "sqlite" | "postgres",
+): KyselyDriverPublic {
+  return {
+    db,
+    dialect,
+
+    async selectOne(spec: SelectSpec): Promise<Row | null> {
+      let q = (db as RawKysely).selectFrom(spec.table).select(spec.columns);
+      q = applyWhere(q, spec.where);
+      q = applyOrderLimit(q, spec.orderBy, 1, undefined);
+      const rows = await q.execute();
+      return (rows[0] as Row | undefined) ?? null;
+    },
+
+    async selectMany(spec: SelectSpec): Promise<Row[]> {
+      let q = (db as RawKysely).selectFrom(spec.table).select(spec.columns);
+      q = applyWhere(q, spec.where);
+      q = applyOrderLimit(q, spec.orderBy, spec.limit, spec.offset);
+      return (await q.execute()) as Row[];
+    },
+
+    async count(spec: CountSpec): Promise<number> {
+      let q = (db as RawKysely).selectFrom(spec.table).select((eb: AnyExprBuilder) => eb.fn.countAll().as("c"));
+      q = applyWhere(q, spec.where);
+      const rows = (await q.execute()) as Array<{ c: number | string | bigint }>;
+      const v = rows[0]?.c;
+      return typeof v === "number" ? v : Number(v ?? 0);
+    },
+
+    async insert(spec: InsertSpec): Promise<Row> {
+      try {
+        const result = await (db as RawKysely)
+          .insertInto(spec.table)
+          .values(spec.values)
+          .returning(spec.returning)
+          .executeTakeFirstOrThrow();
+        return result as Row;
+      } catch (err) {
+        throw mapDriverError(err, spec.table, dialect);
+      }
+    },
+
+    async insertMany(spec: InsertManySpec): Promise<Row[]> {
+      try {
+        const rows = await (db as RawKysely)
+          .insertInto(spec.table)
+          .values(spec.rows)
+          .returning(spec.returning)
+          .execute();
+        return rows as Row[];
+      } catch (err) {
+        throw mapDriverError(err, spec.table, dialect);
+      }
+    },
+
+    async update(spec: UpdateSpec): Promise<Row | null> {
+      try {
+        let q = (db as RawKysely).updateTable(spec.table).set(spec.values);
+        q = applyWhere(q, spec.where);
+        const rows = await q.returning(spec.returning).execute();
+        return ((rows as Row[])[0]) ?? null;
+      } catch (err) {
+        throw mapDriverError(err, spec.table, dialect);
+      }
+    },
+
+    async updateMany(spec: UpdateManySpec): Promise<number> {
+      try {
+        let q = (db as RawKysely).updateTable(spec.table).set(spec.values);
+        q = applyWhere(q, spec.where);
+        const result = await q.executeTakeFirst() as { numUpdatedRows?: bigint | number } | undefined;
+        return Number(result?.numUpdatedRows ?? 0);
+      } catch (err) {
+        throw mapDriverError(err, spec.table, dialect);
+      }
+    },
+
+    async delete(spec: DeleteSpec): Promise<number> {
+      try {
+        let q = (db as RawKysely).deleteFrom(spec.table);
+        q = applyWhere(q, spec.where);
+        const result = await q.executeTakeFirst() as { numDeletedRows?: bigint | number } | undefined;
+        return Number(result?.numDeletedRows ?? 0);
+      } catch (err) {
+        throw mapDriverError(err, spec.table, dialect);
+      }
+    },
+
+    async deleteMany(spec: DeleteManySpec): Promise<number> {
+      try {
+        let q = (db as RawKysely).deleteFrom(spec.table);
+        q = applyWhere(q, spec.where);
+        const result = await q.executeTakeFirst() as { numDeletedRows?: bigint | number } | undefined;
+        return Number(result?.numDeletedRows ?? 0);
+      } catch (err) {
+        throw mapDriverError(err, spec.table, dialect);
+      }
+    },
+
+    async transaction<T>(fn: (txDriver: PersistenceDriver) => Promise<T>): Promise<T> {
+      return await db.transaction().execute(async (trx) => {
+        const txDriver = makeKyselyDriver(trx as Kysely<Record<string, Row>>, dialect);
+        return await fn(txDriver);
+      });
+    },
+  };
+}
+
+interface HasWhere<Q> {
+  where(cb: (eb: AnyExprBuilder) => Expression<SqlBool>): Q;
+}
+
+function applyWhere<Q extends HasWhere<Q>>(q: Q, where: WhereClause | undefined): Q {
+  if (!where) return q;
+  return q.where((eb: AnyExprBuilder) => buildExpression(eb, where));
+}
+
+function buildExpression(eb: AnyExprBuilder, w: WhereClause): Expression<SqlBool> {
+  switch (w.kind) {
+    case "eq": return w.value === null ? eb(w.column, "is", null) : eb(w.column, "=", w.value);
+    case "ne": return w.value === null ? eb(w.column, "is not", null) : eb(w.column, "<>", w.value);
+    case "gt": return eb(w.column, ">", w.value);
+    case "gte": return eb(w.column, ">=", w.value);
+    case "lt": return eb(w.column, "<", w.value);
+    case "lte": return eb(w.column, "<=", w.value);
+    case "like": return eb(w.column, "like", w.pattern);
+    case "in": return eb(w.column, "in", w.values);
+    case "isNull": return w.not ? eb(w.column, "is not", null) : eb(w.column, "is", null);
+    case "and": return eb.and(w.clauses.map((c: WhereClause) => buildExpression(eb, c)));
+    default: {
+      const exhaustive: never = w;
+      throw new Error(`Unhandled WhereClause kind: ${JSON.stringify(exhaustive)}`);
+    }
+  }
+}
+
+function applyOrderLimit(
+  q: AnyQuery,
+  orderBy: { column: string; direction: "asc" | "desc" }[] | undefined,
+  limit: number | undefined,
+  offset: number | undefined,
+): AnyQuery {
+  let out = q;
+  if (orderBy) {
+    for (const ob of orderBy) {
+      out = out.orderBy(ob.column, ob.direction);
+    }
+  }
+  if (limit !== undefined) out = out.limit(limit);
+  if (offset !== undefined) out = out.offset(offset);
+  return out;
+}
+
+function mapDriverError(err: unknown, table: string, dialect: "sqlite" | "postgres"): unknown {
+  if (!(err instanceof Error)) return err;
+  const msg = err.message;
+  const code = (err as { code?: string }).code;
+
+  if (dialect === "sqlite") {
+    const kind = sqliteConstraintKind(code, msg);
+    if (kind !== null) {
+      const field = extractSqliteField(kind, msg);
+      return new ConstraintViolationError(msg, {
+        kind, table, ...(field !== undefined ? { field } : {}), cause: err,
+      });
+    }
+    return err;
+  }
+
+  // Postgres pg driver attaches SQLSTATE on `.code`.
+  if (code === "23505") return new ConstraintViolationError(msg, { kind: "unique", table, cause: err });
+  if (code === "23503") return new ConstraintViolationError(msg, { kind: "foreign_key", table, cause: err });
+  if (code === "23502") return new ConstraintViolationError(msg, { kind: "not_null", table, cause: err });
+  if (code === "23514") return new ConstraintViolationError(msg, { kind: "check", table, cause: err });
+
+  return err;
+}
+
+// libsql wraps better-sqlite3, which maps SQLite extended error codes to
+// strings like SQLITE_CONSTRAINT_UNIQUE. Older/server-mode libsql may only
+// surface SQLITE_CONSTRAINT and signal the kind in the message — fall through
+// to message-parse in that case.
+function sqliteConstraintKind(
+  code: string | undefined,
+  msg: string,
+): "unique" | "foreign_key" | "not_null" | "check" | null {
+  if (code === "SQLITE_CONSTRAINT_UNIQUE" || code === "SQLITE_CONSTRAINT_PRIMARYKEY") return "unique";
+  if (code === "SQLITE_CONSTRAINT_FOREIGNKEY") return "foreign_key";
+  if (code === "SQLITE_CONSTRAINT_NOTNULL") return "not_null";
+  if (code === "SQLITE_CONSTRAINT_CHECK") return "check";
+  if (code === "SQLITE_CONSTRAINT" || code === undefined) {
+    if (msg.includes("UNIQUE constraint failed")) return "unique";
+    if (msg.includes("FOREIGN KEY constraint failed")) return "foreign_key";
+    if (msg.includes("NOT NULL constraint failed")) return "not_null";
+    if (msg.includes("CHECK constraint failed")) return "check";
+  }
+  return null;
+}
+
+function extractSqliteField(kind: "unique" | "foreign_key" | "not_null" | "check", msg: string): string | undefined {
+  const pattern = kind === "unique" ? /UNIQUE constraint failed: ([^\s,]+)/
+    : kind === "not_null" ? /NOT NULL constraint failed: ([^\s,]+)/
+    : null;
+  if (!pattern) return undefined;
+  const m = msg.match(pattern);
+  return m ? m[1]?.split(".")[1] : undefined;
+}

package/src/drizzle-fastify/filter-allowlist.ts

@@ -0,0 +1,31 @@
+/**
+ * Per-entity filter+sort allowlist generated by codegen-ts from @filterable/@sortable
+ * metadata. Validates incoming HTTP filter params at the route boundary so the
+ * Drizzle query layer never sees an unwhitelisted (field, op) combination.
+ */
+
+// FILTER_OPS, FilterOp, OPS_BY_SUBTYPE, and opsForSubType are canonical in
+// @metaobjectsdev/metadata — import from there and re-export for backwards compat.
+import {
+  FILTER_OPS,
+  OPS_BY_SUBTYPE,
+  opsForSubType,
+  type FilterOp,
+} from "@metaobjectsdev/metadata";
+export { FILTER_OPS, OPS_BY_SUBTYPE, opsForSubType, type FilterOp };
+
+export type FilterSubType = "string" | "number" | "boolean" | "datetime";
+
+export interface FilterFieldRule {
+  readonly ops: readonly FilterOp[];
+  readonly subType: FilterSubType;
+  readonly leadingWildcard: boolean;
+}
+
+export type FilterAllowlist = Readonly<Record<string, FilterFieldRule>>;
+
+export interface SortFieldRule {
+  readonly defaultOrder?: "asc" | "desc";
+}
+
+export type SortAllowlist = Readonly<Record<string, SortFieldRule>>;