okmodel 0.0.0 → 0.1.0

package/dist/shared/px90pf9p.js

@@ -0,0 +1,396 @@
+import {
+  decodeResult,
+  emitJoin,
+  emitWhere,
+  emitOrder,
+  emitPrimaryOrder,
+  selectedColumns,
+  rejectKeys,
+  readLimit,
+  projectExpr,
+  jsonExpr,
+  cell,
+  indexes,
+  quote,
+  list,
+  isRecord,
+  fail
+} from "./f5thc1s0.js";
+import {
+  throwNamed2
+} from "./ycwz42az.js";
+
+// src/runtime/include.ts
+var INCLUDE_OPTIONS = ["all", "include", "limit", "orderBy", "select", "where"];
+function emitIncludeSelect(include, alias, sink, outputs, column) {
+  const selected = include.columns;
+  sink.mark(`i:${include.name}:${include.relation.kind}`);
+  if (include.relation.kind === "many") {
+    if (column > 0 || outputs?.fields.length)
+      sink.text(", ");
+    sink.text(alias);
+    sink.text(".rows");
+    outputs?.includes.push({
+      name: include.name,
+      kind: "many",
+      at: column,
+      fields: selected.map((item, index) => ({
+        key: item.field,
+        at: index,
+        decode: item.decode
+      })),
+      nested: include.nested.map((nested, index) => ({
+        name: nested.name,
+        kind: nested.relation.kind,
+        at: selected.length + index,
+        fields: nested.columns.map((item, at) => ({
+          key: item.field,
+          at,
+          decode: item.decode
+        })),
+        nested: []
+      }))
+    });
+    return column + 1;
+  }
+  const projected = include.presence === undefined ? selected : [...selected, include.presence];
+  const start = column;
+  for (let index = 0;index < projected.length; index += 1) {
+    if (start + index > 0)
+      sink.text(", ");
+    sink.text(alias);
+    sink.text(".c");
+    sink.text(String(index));
+    sink.mark(`s:${projected[index]?.field ?? ""}`);
+  }
+  const nestedStart = start + projected.length;
+  let cursor = nestedStart;
+  const nestedOut = [];
+  for (let index = 0;index < include.nested.length; index += 1) {
+    const nested = include.nested[index];
+    if (nested === undefined)
+      continue;
+    const width = nested.relation.kind === "many" ? 1 : nested.presence === undefined ? nested.columns.length : nested.columns.length + 1;
+    for (let slot = 0;slot < width; slot += 1) {
+      sink.text(", ");
+      sink.text(alias);
+      sink.text(".n");
+      sink.text(String(index));
+      sink.text("_");
+      sink.text(String(slot));
+    }
+    nestedOut.push({
+      name: nested.name,
+      kind: nested.relation.kind,
+      at: nested.relation.kind === "many" ? cursor : nested.presence === undefined ? cursor : cursor + nested.columns.length,
+      fields: nested.columns.map((item, at) => ({
+        key: item.field,
+        at: nested.relation.kind === "many" ? at : cursor + at,
+        decode: item.decode
+      })),
+      nested: []
+    });
+    cursor += width;
+  }
+  outputs?.includes.push({
+    name: include.name,
+    kind: "one",
+    at: start + include.anchor,
+    fields: selected.map((item, index) => ({
+      key: item.field,
+      at: start + index,
+      decode: item.decode
+    })),
+    nested: nestedOut
+  });
+  return cursor;
+}
+function emitIncludeJoin(schema, include, sink, parentAlias, alias, depth) {
+  const child = indexes(schema).get(include.relation.table);
+  if (child === undefined) {
+    fail("OKM1120", `Relation ${include.name} names ${include.relation.table}, which is not in the schema.`);
+  }
+  const childAlias = `r${String(depth)}_${include.name}`;
+  sink.text(" left join lateral (");
+  if (include.relation.kind === "many") {
+    sink.text("select coalesce(json_agg(item order by ord), '[]'::json) as rows from (select item, row_number() over () as ord from (select json_build_array(");
+    const selected = include.columns;
+    for (let index = 0;index < selected.length; index += 1) {
+      const item = selected[index];
+      if (item === undefined)
+        continue;
+      if (index > 0)
+        sink.text(", ");
+      sink.text(jsonExpr(`${childAlias}.${quote(item.sql)}`, item.dataType));
+    }
+    if (selected.length === 0)
+      sink.text("1");
+    for (const nested of include.nested) {
+      sink.text(", ");
+      emitNestedAggregate(schema, nested, sink, childAlias, depth + 1);
+    }
+    sink.text(") as item from ");
+    sink.text(quote(child.model.sql));
+    sink.text(" ");
+    sink.text(childAlias);
+    sink.text(" where ");
+    emitJoin(sink, parentAlias, childAlias, include.relation);
+    emitWhere(schema, child, include.where, sink, childAlias, depth + 1, true);
+    emitOrder(child, include.orderBy, sink, childAlias);
+    if (include.orderBy === undefined && child.model.primary.length > 0) {
+      emitPrimaryOrder(child, sink, childAlias);
+    }
+    if (include.limit !== undefined) {
+      sink.text(" limit ");
+      sink.param(String(include.limit));
+      sink.mark(`l:${String(include.limit)}`);
+    }
+    sink.text(") limited) ordered) ");
+    sink.text(alias);
+    sink.text(" on true");
+    return;
+  }
+  sink.text("select ");
+  const projected = include.presence === undefined ? include.columns : [...include.columns, include.presence];
+  for (let index = 0;index < projected.length; index += 1) {
+    const item = projected[index];
+    if (item === undefined)
+      continue;
+    if (index > 0)
+      sink.text(", ");
+    sink.text(projectExpr(`${childAlias}.${quote(item.sql)}`, item.dataType));
+    sink.text(" as c");
+    sink.text(String(index));
+  }
+  if (projected.length === 0)
+    sink.text("1 as c0");
+  for (let index = 0;index < include.nested.length; index += 1) {
+    const nested = include.nested[index];
+    if (nested === undefined)
+      continue;
+    if (nested.relation.kind === "many") {
+      sink.text(", ");
+      sink.text("n");
+      sink.text(String(index));
+      sink.text(".rows as n");
+      sink.text(String(index));
+      sink.text("_0");
+      continue;
+    }
+    const width = nested.presence === undefined ? nested.columns.length : nested.columns.length + 1;
+    for (let slot = 0;slot < width; slot += 1) {
+      sink.text(", ");
+      sink.text("n");
+      sink.text(String(index));
+      sink.text(".c");
+      sink.text(String(slot));
+      sink.text(" as n");
+      sink.text(String(index));
+      sink.text("_");
+      sink.text(String(slot));
+    }
+  }
+  sink.text(" from ");
+  sink.text(quote(child.model.sql));
+  sink.text(" ");
+  sink.text(childAlias);
+  for (let index = 0;index < include.nested.length; index += 1) {
+    const nested = include.nested[index];
+    if (nested === undefined)
+      continue;
+    emitIncludeJoin(schema, nested, sink, childAlias, `n${String(index)}`, depth + 1);
+  }
+  sink.text(" where ");
+  emitJoin(sink, parentAlias, childAlias, include.relation);
+  emitWhere(schema, child, include.where, sink, childAlias, depth + 1, true);
+  sink.text(" limit 1) ");
+  sink.text(alias);
+  sink.text(" on true");
+}
+function emitNestedAggregate(schema, include, sink, alias, depth) {
+  const child = indexes(schema).get(include.relation.table);
+  if (child === undefined) {
+    fail("OKM1120", `Relation ${include.name} names ${include.relation.table}, which is not in the schema.`);
+  }
+  const childAlias = `n${String(depth)}_${include.name}`;
+  sink.text("(select coalesce(json_agg(item order by ord), '[]'::json) from (select item, row_number() over () as ord from (select json_build_array(");
+  for (let index = 0;index < include.columns.length; index += 1) {
+    const item = include.columns[index];
+    if (item === undefined)
+      continue;
+    if (index > 0)
+      sink.text(", ");
+    sink.text(jsonExpr(`${childAlias}.${quote(item.sql)}`, item.dataType));
+  }
+  if (include.columns.length === 0)
+    sink.text("1");
+  sink.text(") as item from ");
+  sink.text(quote(child.model.sql));
+  sink.text(" ");
+  sink.text(childAlias);
+  sink.text(" where ");
+  emitJoin(sink, alias, childAlias, include.relation);
+  emitWhere(schema, child, include.where, sink, childAlias, depth, true);
+  emitOrder(child, include.orderBy, sink, childAlias);
+  if (include.orderBy === undefined && child.model.primary.length > 0) {
+    emitPrimaryOrder(child, sink, childAlias);
+  }
+  if (include.limit !== undefined) {
+    sink.text(" limit ");
+    sink.param(String(include.limit));
+    sink.mark(`l:${String(include.limit)}`);
+  }
+  sink.text(") limited) ordered)");
+}
+function readIncludes(schema, table, include, all) {
+  if (include === undefined)
+    return [];
+  if (!isRecord(include)) {
+    fail("OKM1120", "include must be an object of relations.");
+  }
+  const parsed = [];
+  for (const name of Object.keys(include)) {
+    const relation = table.relations.get(name);
+    if (relation === undefined) {
+      throwNamed2("OKM1120", name, [...table.relations.keys()], `Include ${name} is not a relation of ${table.model.name}. Accepted names: ${list([...table.relations.keys()])}.`);
+    }
+    parsed.push(parseInclude(schema, name, relation, include[name], all));
+  }
+  return parsed;
+}
+function parseInclude(schema, name, relation, value, all) {
+  if (value === true) {
+    if (relation.kind === "many" && all === undefined) {
+      fail("OKM1105", `Include ${name} is to-many and has no limit. Pass limit, or call .all(reason).`);
+    }
+    const child = childIndex(schema, relation);
+    const columns = selectedColumns(child, undefined);
+    return {
+      name,
+      relation,
+      where: undefined,
+      orderBy: undefined,
+      limit: undefined,
+      columns,
+      ...anchored(child, columns),
+      nested: []
+    };
+  }
+  if (!isRecord(value)) {
+    fail("OKM1120", `Include ${name} must be true or an object.`);
+  }
+  rejectKeys(value, INCLUDE_OPTIONS, `include ${name}`);
+  const reason = typeof value.all === "string" ? value.all : all;
+  let limit;
+  if (value.limit !== undefined)
+    limit = readLimit(value.limit);
+  if (relation.kind === "many" && limit === undefined && reason === undefined) {
+    fail("OKM1105", `Include ${name} is to-many and has no limit. Pass limit, or call .all(reason).`);
+  }
+  const child = childIndex(schema, relation);
+  const columns = selectedColumns(child, value.select);
+  const nestedValue = value.include;
+  const nested = nestedValue === undefined ? [] : readIncludes(schema, child, nestedValue, reason);
+  return {
+    name,
+    relation,
+    where: value.where,
+    orderBy: value.orderBy,
+    limit,
+    columns,
+    ...anchored(child, columns),
+    nested
+  };
+}
+function anchored(table, columns) {
+  const pk = table.model.primary[0];
+  const selected = pk === undefined ? -1 : columns.findIndex((column) => column.field === pk);
+  if (selected >= 0)
+    return { presence: undefined, anchor: selected };
+  return { presence: pk === undefined ? undefined : table.columns.get(pk), anchor: columns.length };
+}
+function childIndex(schema, relation) {
+  const child = indexes(schema).get(relation.table);
+  if (child === undefined) {
+    fail("OKM1120", `Relation ${relation.name} names ${relation.table}, which is not in the schema.`);
+  }
+  return child;
+}
+function decodeIncluded(plan, rows, table) {
+  return decodeResult(plan, rows, table, decodeRowIncluded);
+}
+function decodeRowIncluded(outputs, row) {
+  const result = {};
+  for (const field of outputs.fields) {
+    result[field.key] = cell(row[field.at], field.decode);
+  }
+  for (const include of outputs.includes) {
+    result[include.name] = decodeInclude(include, row);
+  }
+  return result;
+}
+function decodeInclude(include, row) {
+  if (include.kind === "many") {
+    const raw = row[include.at];
+    if (raw === null || raw === undefined)
+      return [];
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed))
+      return [];
+    const rows = [];
+    for (const item of parsed) {
+      if (!Array.isArray(item))
+        continue;
+      const child = {};
+      for (const field of include.fields) {
+        child[field.key] = jsonCell(item[field.at], field.decode);
+      }
+      for (const nested of include.nested) {
+        child[nested.name] = decodeJsonInclude(nested, item[nested.at]);
+      }
+      rows.push(child);
+    }
+    return rows;
+  }
+  const presence = row[include.at];
+  if (presence === null || presence === undefined)
+    return null;
+  const child = {};
+  for (const field of include.fields) {
+    child[field.key] = cell(row[field.at], field.decode);
+  }
+  for (const nested of include.nested) {
+    child[nested.name] = decodeInclude(nested, row);
+  }
+  return child;
+}
+function decodeJsonInclude(include, value) {
+  if (!Array.isArray(value))
+    return include.kind === "many" ? [] : null;
+  const rows = [];
+  for (const item of value) {
+    if (!Array.isArray(item))
+      continue;
+    const child = {};
+    for (const field of include.fields) {
+      child[field.key] = jsonCell(item[field.at], field.decode);
+    }
+    rows.push(child);
+  }
+  return include.kind === "one" ? rows[0] ?? null : rows;
+}
+function jsonCell(value, decode) {
+  if (value === null || value === undefined)
+    return null;
+  const wire = typeof value === "string" ? value : JSON.stringify(value);
+  return decode === undefined ? wire : decode(wire);
+}
+var includeHooks = {
+  read: readIncludes,
+  select: emitIncludeSelect,
+  join: emitIncludeJoin
+};
+export {
+  decodeIncluded,
+  includeHooks
+};

package/dist/shared/qk3hxfja.js

@@ -0,0 +1,83 @@
+import {
+  OkmError2
+} from "./ycwz42az.js";
+
+// src/runtime/drift.ts
+async function assertCompatible(pool, schema, recordedHash, source, options) {
+  const code = await codeHash(schema, source);
+  if (code.hash === recordedHash)
+    return;
+  if (code.artifact !== undefined) {
+    const { loadTrustedCatalog } = await import("./w8samvk1.js");
+    loadTrustedCatalog(code.artifact.text, code.artifact.hash);
+  } else {
+    const artifact = await readCatalogFile(source.catalogDir);
+    if (artifact !== undefined) {
+      const { loadTrustedCatalog } = await import("./w8samvk1.js");
+      loadTrustedCatalog(artifact.text, artifact.hash);
+    }
+  }
+  const { assertDrift } = await import("./p0cbr3g2.js");
+  await assertDrift(pool, code.hash, recordedHash, options);
+}
+async function codeHash(schema, source) {
+  if (source.catalog !== undefined)
+    return { hash: source.catalog.hash, artifact: source.catalog };
+  const listed = await readHashFile(source.catalogDir);
+  if (listed !== undefined)
+    return { hash: listed };
+  const { catalogHash } = await import("./w8samvk1.js");
+  return { hash: catalogHash(schemaCatalog(schema)) };
+}
+function schemaCatalog(schema) {
+  const value = Reflect.get(schema, "catalog");
+  if (typeof value !== "object" || value === null || !("objects" in value)) {
+    throw new OkmError2("OKM1520", "The schema has no catalog to compare.", {
+      fix: {
+        summary: "Pass the schema() result to connect, or a catalog artifact from okm build."
+      }
+    });
+  }
+  return value;
+}
+async function readHashFile(catalogDir) {
+  const text = await readText(`${artifactDir(catalogDir)}/catalog.hash`);
+  if (text === undefined)
+    return;
+  const hash = text.trim();
+  return hash.length === 0 ? undefined : hash;
+}
+async function readCatalogFile(catalogDir) {
+  const dir = artifactDir(catalogDir);
+  const hash = await readHashFile(catalogDir);
+  const text = await readText(`${dir}/catalog.json`);
+  if (hash === undefined || text === undefined)
+    return;
+  return { text, hash };
+}
+function artifactDir(catalogDir) {
+  if (catalogDir !== undefined)
+    return catalogDir.replace(/\/$/, "");
+  const cwd = globalThis.process?.cwd?.() ?? ".";
+  return `${cwd}/.okm`;
+}
+async function readText(path) {
+  const bun = globalThis.Bun;
+  if (bun !== undefined) {
+    const file = bun.file(path);
+    if (!await file.exists())
+      return;
+    return file.text();
+  }
+  const loader = globalThis.process?.getBuiltinModule;
+  if (loader === undefined)
+    return;
+  try {
+    return await loader("node:fs/promises").readFile(path, "utf8");
+  } catch {
+    return;
+  }
+}
+export {
+  assertCompatible
+};

package/dist/shared/tb4ze1tr.js

@@ -0,0 +1,119 @@
+import {
+  PgSession
+} from "./7ck0dtry.js";
+import {
+  driverErrors,
+  rejectClosed,
+  mapFailure,
+  runCall,
+  rowsFrom
+} from "./xy79j5hq.js";
+
+// src/adapters/pg/postgres-extra.ts
+var RESET_ALL = "RESET ALL";
+var UNLOCK = "SELECT pg_advisory_unlock_all()";
+async function checkout(pool) {
+  if (pool.isClosed())
+    return rejectClosed();
+  const reserved = await reserveConnection(pool.sql, pool.acquireMs, pool.counters);
+  pool.counters.reserved += 1;
+  const local = new Set;
+  const session = new PgSession(reserved, pool.counters, "reserved", local, pool.isClosed, pool.poolInflight, pool.notices, pool.named);
+  let released = false;
+  return {
+    execute: (text, params, options) => runCall(pool.isClosed(), options, (watch) => session.query(text, params, watch)),
+    batch: (statements, options) => runCall(pool.isClosed(), options, async (watch) => {
+      const { runAtomicBatch } = await import("./dynq16vb.js");
+      return runAtomicBatch(session, statements, watch);
+    }),
+    cancel() {
+      session.cancel();
+    },
+    async release() {
+      if (released)
+        return;
+      released = true;
+      try {
+        await resetConnection(reserved, session.depth());
+      } finally {
+        pool.counters.reserved = Math.max(0, pool.counters.reserved - 1);
+        reserved.release();
+      }
+    }
+  };
+}
+async function describe(sql, text, params) {
+  const pending = sql.unsafe(text, asParams(params), { prepare: true });
+  const described = await pending.describe();
+  return {
+    columns: described.columns.map((column) => column.name),
+    parameterCount: described.types.length
+  };
+}
+async function* stream(sql, text, params) {
+  const pending = sql.unsafe(text, asParams(params));
+  for await (const chunk of pending.cursor(64)) {
+    yield rowsFrom(chunk);
+  }
+}
+function reserveConnection(sql, acquireMs, counters) {
+  counters.waiting += 1;
+  let settled = false;
+  return new Promise((resolve, reject) => {
+    let timer;
+    if (acquireMs !== undefined) {
+      timer = setTimeout(() => {
+        settled = true;
+        counters.waiting = Math.max(0, counters.waiting - 1);
+        driverErrors().then((errors) => {
+          reject(errors.acquireTimeout());
+        });
+      }, acquireMs);
+    }
+    sql.reserve().then((connection) => {
+      if (settled) {
+        resetConnection(connection, 0).finally(() => {
+          connection.release();
+        });
+        return;
+      }
+      if (timer !== undefined)
+        clearTimeout(timer);
+      counters.waiting = Math.max(0, counters.waiting - 1);
+      resolve(connection);
+    }, (error) => {
+      if (settled)
+        return;
+      if (timer !== undefined)
+        clearTimeout(timer);
+      counters.waiting = Math.max(0, counters.waiting - 1);
+      mapFailure(error).then(reject);
+    });
+  });
+}
+async function resetConnection(sql, depth) {
+  if (depth > 0)
+    await sql.unsafe("ROLLBACK").catch(() => {
+      return;
+    });
+  try {
+    await sql.unsafe(RESET_ALL);
+    await sql.unsafe(UNLOCK);
+  } catch {
+    await sql.unsafe("ROLLBACK").catch(() => {
+      return;
+    });
+    await sql.unsafe(RESET_ALL);
+    await sql.unsafe(UNLOCK);
+  }
+}
+function asParams(params) {
+  if (params === undefined)
+    return [];
+  return params;
+}
+export {
+  checkout,
+  describe,
+  stream
+};

package/dist/shared/vkm3q4x1.js

@@ -0,0 +1,30 @@
+import"./y9m15dfv.js";
+import {
+  listTargets,
+  loadConfig
+} from "./kynx7vbm.js";
+
+// src/tooling/migrate/dev.ts
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+async function devProject(cwd) {
+  const config = await loadConfig(cwd);
+  const named = listTargets(config).find((target) => target.name === "dev");
+  if (named !== undefined)
+    return `target ${named.name}
+`;
+  const directory = join(cwd, config.out ?? ".okm", "dev-db");
+  mkdirSync(directory, { recursive: true });
+  const { open } = await import("./8b04d28c.js");
+  const pool = await open({ dataDir: directory });
+  try {
+    await pool.execute("select 1");
+  } finally {
+    await pool.close();
+  }
+  return `${directory}
+`;
+}
+export {
+  devProject
+};

package/dist/shared/w8samvk1.js

@@ -0,0 +1,18 @@
+import {
+  creationOrder2,
+  renameColumn2,
+  renameTable2,
+  serializeCatalog2,
+  catalogHash2,
+  loadTrustedCatalog2,
+  parseCatalog2
+} from "./y9m15dfv.js";
+export {
+  catalogHash2 as catalogHash,
+  creationOrder2 as creationOrder,
+  loadTrustedCatalog2 as loadTrustedCatalog,
+  parseCatalog2 as parseCatalog,
+  renameColumn2 as renameColumn,
+  renameTable2 as renameTable,
+  serializeCatalog2 as serializeCatalog
+};