okmodel 0.0.0 → 0.1.1

package/dist/shared/hadrfb9h.js

@@ -0,0 +1,398 @@
+import {
+  decodeResult,
+  emitJoin,
+  emitWhere,
+  emitOrder,
+  emitPrimaryOrder,
+  selectedColumns,
+  rejectKeys,
+  readLimit,
+  projectExpr,
+  jsonExpr,
+  cell,
+  indexes,
+  quote,
+  list,
+  isRecord,
+  fail
+} from "./rgs0st28.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];
+  if (pk === undefined)
+    return { presence: undefined, anchor: 0 };
+  const selected = columns.findIndex((column) => column.field === pk);
+  if (selected >= 0)
+    return { presence: undefined, anchor: selected };
+  return { presence: 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/hd293j9g.js

@@ -0,0 +1,98 @@
+import {
+  OkmError2
+} from "./ycwz42az.js";
+
+// src/adapters/error.ts
+class DriverError2 extends Error {
+  sqlstate;
+  constraint;
+  table;
+  column;
+  detail;
+  cause;
+  batchIndex;
+  kind;
+  constructor(message, fields = {}) {
+    super(message);
+    this.name = "DriverError";
+    this.sqlstate = fields.sqlstate;
+    this.constraint = fields.constraint;
+    this.table = fields.table;
+    this.column = fields.column;
+    this.detail = fields.detail;
+    this.cause = fields.cause;
+    this.batchIndex = fields.batchIndex === undefined ? null : fields.batchIndex;
+    this.kind = fields.kind;
+  }
+  at(batchIndex) {
+    if (this.batchIndex === batchIndex)
+      return this;
+    return new DriverError2(this.message, driverFields({
+      sqlstate: this.sqlstate,
+      constraint: this.constraint,
+      table: this.table,
+      column: this.column,
+      detail: this.detail,
+      cause: this.cause,
+      kind: this.kind,
+      batchIndex
+    }));
+  }
+}
+function cancelled2(cause) {
+  return new DriverError2("The call was cancelled.", driverFields({ kind: "cancelled", cause }));
+}
+function timedOut2(cause) {
+  return new DriverError2("The call timed out.", driverFields({ kind: "timeout", cause }));
+}
+function outcomeUnknown2(cause) {
+  return new DriverError2("The commit outcome is unknown. The result never arrived.", driverFields({ kind: "outcome_unknown", cause, batchIndex: null }));
+}
+function acquireTimeout2() {
+  return new OkmError2("OKM1846", "Timed out waiting for a connection. This pool did not hand one out within timeouts.acquire.");
+}
+function errorField2(error, key) {
+  if (typeof error !== "object" || error === null || !(key in error))
+    return;
+  const value = Reflect.get(error, key);
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function mapDriverError2(error, batchIndex) {
+  if (error instanceof OkmError2)
+    return error;
+  if (error instanceof DriverError2) {
+    return batchIndex === undefined ? error : error.at(batchIndex);
+  }
+  const message = error instanceof Error ? error.message : "driver error";
+  return new DriverError2(message, driverFields({
+    sqlstate: errorField2(error, "code") ?? errorField2(error, "sqlstate"),
+    constraint: errorField2(error, "constraint_name") ?? errorField2(error, "constraint"),
+    table: errorField2(error, "table_name") ?? errorField2(error, "table"),
+    column: errorField2(error, "column_name") ?? errorField2(error, "column"),
+    detail: errorField2(error, "detail"),
+    cause: error,
+    batchIndex
+  }));
+}
+function driverFields(input) {
+  const fields = {};
+  if (input.sqlstate !== undefined)
+    fields.sqlstate = input.sqlstate;
+  if (input.constraint !== undefined)
+    fields.constraint = input.constraint;
+  if (input.table !== undefined)
+    fields.table = input.table;
+  if (input.column !== undefined)
+    fields.column = input.column;
+  if (input.detail !== undefined)
+    fields.detail = input.detail;
+  if (input.cause !== undefined)
+    fields.cause = input.cause;
+  if (input.batchIndex !== undefined)
+    fields.batchIndex = input.batchIndex;
+  if (input.kind !== undefined)
+    fields.kind = input.kind;
+  return fields;
+}
+
+export { DriverError2, cancelled2, timedOut2, outcomeUnknown2, acquireTimeout2, errorField2, mapDriverError2 };