okmodel 0.1.1 → 0.2.1

package/dist/shared/dd4f8mnx.js

@@ -0,0 +1,307 @@
+import {
+  definition,
+  rejected,
+  quoteLiteral,
+  writeArray,
+  readArray
+} from "./xatfg0gn.js";
+import {
+  REFERENTIAL_ACTIONS,
+  referentialAction
+} from "./4e4c6vq2.js";
+import {
+  readClientGenerator
+} from "./rwmrejjz.js";
+
+// src/dialects/pg/column.ts
+class ColumnBuilder2 {
+  state;
+  constructor(state) {
+    this.state = state;
+  }
+  encode(value) {
+    return this.state.encode(value);
+  }
+  decode(wire) {
+    return this.state.decode(wire);
+  }
+  nullable() {
+    return rebuild(this.state, { nullable: true });
+  }
+  default(value) {
+    const clientDefault = readClientGenerator(value);
+    if (clientDefault !== undefined) {
+      return rebuild(this.state, {
+        hasDefault: true,
+        defaultSql: undefined,
+        defaultValue: undefined,
+        clientDefault,
+        generated: undefined
+      });
+    }
+    if (value === null && this.state.nullable === false) {
+      definition("A null default is only accepted on a nullable column. Call .nullable() first.");
+    }
+    if (this.state.picklist !== undefined && value !== null) {
+      const text = String(value);
+      if (!this.state.picklist.values.includes(text)) {
+        definition(`Default ${text} is not in the picklist ${this.state.picklist.values.join(", ")}.`);
+      }
+    }
+    return rebuild(this.state, {
+      hasDefault: true,
+      defaultSql: value === null ? "NULL" : sqlOf(this.state, value),
+      defaultValue: value,
+      clientDefault: undefined,
+      generated: undefined
+    });
+  }
+  defaultSql(expression) {
+    if (expression.length === 0) {
+      definition("defaultSql must be a non-empty SQL expression.");
+    }
+    return rebuild(this.state, {
+      hasDefault: true,
+      defaultSql: expression,
+      defaultValue: undefined,
+      clientDefault: undefined,
+      generated: undefined
+    });
+  }
+  primaryKey() {
+    return rebuild(this.state, {
+      primaryKey: true,
+      omitUpdate: true
+    });
+  }
+  unique(options) {
+    const marker = options?.global;
+    if (typeof marker === "string" && marker.trim().length === 0) {
+      definition("unique() global needs a reason.");
+    }
+    const named = typeof marker === "string" ? marker.trim() : undefined;
+    const globalFlag = typeof marker === "string" ? true : marker;
+    return rebuild(this.state, {
+      unique: {
+        reason: named ?? options?.reason,
+        global: globalFlag
+      }
+    });
+  }
+  picklist(values, options) {
+    if (values.length === 0) {
+      definition("A picklist must contain at least one value.");
+    }
+    const allowed = new Set;
+    for (const value of values) {
+      if (value.length === 0) {
+        definition("Picklist values must be non-empty strings.");
+      }
+      if (allowed.has(value)) {
+        definition(`Picklist value ${value} is repeated. Each value is accepted once.`);
+      }
+      allowed.add(value);
+    }
+    if (typeof this.state.defaultValue === "string" && !allowed.has(this.state.defaultValue)) {
+      definition(`Default ${this.state.defaultValue} is not in the picklist ${values.join(", ")}.`);
+    }
+    const previous = this.state.elementEncode;
+    const elementEncode = (value) => {
+      if (typeof value !== "string" || !allowed.has(value)) {
+        rejected(`Picklist rejected ${String(value)}. Accepted values: ${[...allowed].join(", ")}.`);
+      }
+      return previous(value);
+    };
+    return rebuild(this.state, {
+      picklist: { values: values.slice(), check: options?.check !== false },
+      elementEncode,
+      encode: elementEncode
+    });
+  }
+  generated(expression, options) {
+    if (expression.length === 0) {
+      definition("generated() must be a non-empty SQL expression.");
+    }
+    return rebuild(this.state, {
+      generated: { stored: options?.stored !== false, expression },
+      hasDefault: true,
+      defaultSql: undefined,
+      defaultValue: undefined,
+      clientDefault: undefined
+    });
+  }
+  guarded() {
+    return rebuild(this.state, { guarded: true });
+  }
+  hidden() {
+    return rebuild(this.state, { hidden: true });
+  }
+  sensitive() {
+    return rebuild(this.state, { sensitive: true });
+  }
+  validate(rules) {
+    const list = Array.isArray(rules) ? rules : [rules];
+    return rebuild(this.state, { validate: { rules: list } });
+  }
+  references(table, options) {
+    if (table.length === 0) {
+      definition("references() needs a table name.");
+    }
+    const onDelete = readAction(options?.onDelete, "onDelete");
+    const onUpdate = readAction(options?.onUpdate, "onUpdate");
+    const columns = readReferenceColumns(options?.columns);
+    return rebuild(this.state, {
+      references: {
+        table,
+        ...onDelete !== undefined ? { onDelete } : {},
+        ...onUpdate !== undefined ? { onUpdate } : {},
+        ...columns !== undefined ? { columns } : {}
+      }
+    });
+  }
+  renamedFrom(name) {
+    if (name.length === 0) {
+      definition("renamedFrom must be a non-empty previous column name.");
+    }
+    return rebuild(this.state, { renamedFrom: name });
+  }
+  sqlName(name) {
+    if (name.length === 0) {
+      definition("sqlName must be a non-empty SQL identifier.");
+    }
+    return rebuild(this.state, { sqlName: name });
+  }
+  comment(text) {
+    return rebuild(this.state, { comment: text });
+  }
+  array(options) {
+    if (this.state.dims !== 0) {
+      definition("array() accepts a scalar column. This column is already an array.");
+    }
+    const dims = options?.dims ?? 1;
+    if (!Number.isInteger(dims) || dims < 1 || dims > 6) {
+      definition(`Array dims ${String(dims)} must be an integer from 1 to 6.`);
+    }
+    const elementEncode = this.state.elementEncode;
+    const elementDecode = this.state.elementDecode;
+    const raw = this.state.sqlForm === "raw";
+    return rebuild(this.state, {
+      dims,
+      accepts: ["Array"],
+      encode: (value) => writeArray(value, dims, elementEncode, raw),
+      decode: (wire) => readArray(wire, dims, elementDecode)
+    });
+  }
+}
+function required(body) {
+  return openColumn({
+    nullable: false,
+    hasDefault: false,
+    generated: false,
+    guarded: false,
+    hidden: false,
+    omitWrite: false,
+    ...body
+  });
+}
+function openColumn(input) {
+  const elementEncode = input.encode;
+  const elementDecode = input.decode;
+  return new ColumnBuilder2({
+    baseType: input.baseType,
+    dims: 0,
+    nullable: input.nullable,
+    hasDefault: input.hasDefault,
+    defaultSql: input.defaultSql,
+    defaultValue: undefined,
+    clientDefault: input.clientDefault,
+    collation: input.collation,
+    idSource: input.idSource,
+    identity: input.identity,
+    generated: undefined,
+    unique: undefined,
+    picklist: undefined,
+    guarded: input.guarded,
+    hidden: input.hidden,
+    sensitive: false,
+    omitWrite: input.omitWrite,
+    omitUpdate: input.omitUpdate === true,
+    renamedFrom: undefined,
+    sqlName: undefined,
+    comment: undefined,
+    extension: input.extension,
+    typeDependency: input.typeDependency,
+    enumLabels: input.enumLabels,
+    domain: input.domain,
+    primaryKey: input.primaryKey === true,
+    typeLabel: input.typeLabel,
+    references: undefined,
+    validate: undefined,
+    sqlForm: input.sqlForm,
+    encode: input.encode,
+    decode: input.decode,
+    elementEncode,
+    elementDecode,
+    accepts: input.accepts
+  });
+}
+function formatType(baseType, dims) {
+  if (dims === 0) {
+    return baseType;
+  }
+  return baseType + "[]".repeat(dims);
+}
+function sqlOf(state, value) {
+  const encoded = state.encode(value);
+  const typed = formatType(state.baseType, state.dims);
+  if (state.sqlForm === "cast") {
+    return `${quoteLiteral(encoded)}::${typed}`;
+  }
+  if (state.sqlForm === "json") {
+    return `${quoteLiteral(encoded)}::json`;
+  }
+  if (state.sqlForm === "jsonb") {
+    return `${quoteLiteral(encoded)}::jsonb`;
+  }
+  if (state.dims > 0 || state.sqlForm === "quote") {
+    return quoteLiteral(encoded);
+  }
+  return encoded;
+}
+function readAction(action, role) {
+  if (action === undefined) {
+    return;
+  }
+  if (referentialAction(action) === undefined) {
+    definition(`references() ${role} ${action} is not a referential action. Accepted actions: ${REFERENTIAL_ACTIONS.join(", ")}.`);
+  }
+  return action;
+}
+function readReferenceColumns(columns) {
+  if (columns === undefined) {
+    return;
+  }
+  if (columns.length === 0) {
+    definition("references() columns must name at least one target column.");
+  }
+  const copy = [];
+  for (const name of columns) {
+    if (name.length === 0) {
+      definition("references() columns must be non-empty names.");
+    }
+    copy.push(name);
+  }
+  return copy;
+}
+function retarget(column, patch) {
+  return rebuild(column.state, {
+    ...patch.dropUnique === true ? { unique: undefined } : {},
+    ...patch.dropPrimary === true ? { primaryKey: false } : {},
+    ...patch.references !== undefined ? { references: patch.references } : {}
+  });
+}
+function rebuild(state, patch) {
+  return new ColumnBuilder2({ ...state, ...patch });
+}
+
+export { ColumnBuilder2, required, openColumn, formatType, retarget };

package/dist/shared/e6wg00wd.js

@@ -0,0 +1,164 @@
+import {
+  safetyInstalled,
+  runSafety
+} from "./a5sxz52y.js";
+import {
+  isOperator,
+  operatorValue
+} from "./cn0n68ft.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/runtime/exposure.ts
+var REDACTED = "[redacted]";
+var namesOf = new WeakMap;
+function redactView(schema, view, call) {
+  const names = concealedNames(schema);
+  const secrets = new Set;
+  harvest(schema, call.where, names, undefined, secrets);
+  harvest(schema, call.include, names, undefined, secrets);
+  const model = schema.model[call.table];
+  const rules = model === undefined ? view.rules : [...view.rules, ...exposureRules(model, call)];
+  if (safetyInstalled())
+    runSafety(rules, undefined);
+  return {
+    ...view,
+    intent: {
+      ...view.intent,
+      where: walk(view.intent.where, names),
+      include: walk(view.intent.include, names)
+    },
+    rules,
+    sql: {
+      ...view.sql,
+      params: view.sql.params.map((value) => value !== null && secrets.has(value) ? REDACTED : value)
+    }
+  };
+}
+function scrubCall(error, schema, call) {
+  const names = concealedNames(schema);
+  const secrets = new Set;
+  harvest(schema, call.where, names, undefined, secrets);
+  harvest(schema, call.include, names, undefined, secrets);
+  let message = error.message;
+  for (const secret of secrets) {
+    if (secret.length < 4 || !message.includes(secret))
+      continue;
+    message = message.replaceAll(secret, REDACTED);
+  }
+  if (message === error.message)
+    return error;
+  return new OkmError2(error.code, message, {
+    kind: error.kind,
+    ...error.table !== undefined ? { table: error.table } : {},
+    ...error.columns.length > 0 ? { columns: error.columns } : {},
+    fix: error.fix
+  });
+}
+function concealedNames(schema) {
+  const cached = namesOf.get(schema);
+  if (cached !== undefined)
+    return cached;
+  const names = new Set;
+  for (const model of Object.values(schema.model)) {
+    if (model.conceal !== true)
+      continue;
+    for (const column of model.columns) {
+      if (column.hidden || column.sensitive)
+        names.add(column.field);
+    }
+  }
+  namesOf.set(schema, names);
+  return names;
+}
+function exposureRules(model, call) {
+  const named = namedSelect(call.select);
+  const source = model.source;
+  const rules = [];
+  for (const column of model.columns) {
+    if (column.hidden && (named === undefined || !named.has(column.field))) {
+      rules.push({
+        rule: "hidden",
+        contribution: `hidden ${model.name}.${column.field} excluded`,
+        provenance: "catalog",
+        ...source !== undefined ? { source } : {}
+      });
+    }
+    if (column.sensitive) {
+      rules.push({
+        rule: "sensitive",
+        contribution: `sensitive ${model.name}.${column.field} redacted`,
+        provenance: "catalog",
+        ...source !== undefined ? { source } : {}
+      });
+    }
+  }
+  return rules;
+}
+function namedSelect(select) {
+  if (!Array.isArray(select))
+    return;
+  const names = new Set;
+  for (const name of select) {
+    if (typeof name === "string")
+      names.add(name);
+  }
+  return names;
+}
+function harvest(schema, value, names, key, into) {
+  if (Array.isArray(value)) {
+    for (const item of value)
+      harvest(schema, item, names, key, into);
+    return;
+  }
+  if (isOperator(value)) {
+    harvest(schema, operatorValue(value), names, key, into);
+    return;
+  }
+  if (typeof value === "object" && value !== null) {
+    const record = value;
+    for (const child of Object.keys(record))
+      harvest(schema, record[child], names, child, into);
+    return;
+  }
+  if (key === undefined || !names.has(key))
+    return;
+  const encode = encodeOf(schema, key);
+  if (encode === undefined)
+    return;
+  try {
+    into.add(encode(value));
+  } catch {}
+}
+function encodeOf(schema, field) {
+  for (const model of Object.values(schema.model)) {
+    for (const column of model.columns) {
+      if (column.field === field && (column.hidden || column.sensitive)) {
+        return column.encode;
+      }
+    }
+  }
+  return;
+}
+function walk(value, names, key) {
+  if (Array.isArray(value))
+    return value.map((item) => walk(item, names, key));
+  if (typeof value === "object" && value !== null) {
+    const record = value;
+    if (typeof record.op === "string" && "value" in record) {
+      return { op: record.op, value: walk(record.value, names, key) };
+    }
+    const out = {};
+    for (const child of Object.keys(record))
+      out[child] = walk(record[child], names, child);
+    return out;
+  }
+  if (key !== undefined && names.has(key))
+    return REDACTED;
+  return value;
+}
+export {
+  redactView,
+  scrubCall
+};

package/dist/shared/e7a268fy.js

@@ -0,0 +1,195 @@
+import {
+  decodeRows,
+  readHandle,
+  readCall,
+  attachHttp
+} from "./mxmcdsh5.js";
+import {
+  selectedColumns,
+  parseOrder,
+  rejectKeys,
+  readLimit,
+  indexes,
+  quote,
+  list,
+  isRecord,
+  registerFailFix,
+  fail
+} from "./xrfnq5k8.js";
+import {
+  OkmError2,
+  throwNamed2
+} from "./52szzakm.js";
+
+// src/runtime/page.ts
+registerFailFix("OKM1130", "Request the next page with the same orderBy and the exact next value the previous page returned. The cursor encodes that order.");
+var OPTIONS = [
+  "where",
+  "select",
+  "orderBy",
+  "limit",
+  "include",
+  "after",
+  "signal",
+  "timeout"
+];
+function build(session, table, options, mods, view) {
+  try {
+    return plan(session, table, options, mods, view);
+  } catch (error) {
+    throw error instanceof OkmError2 ? attachHttp(session.http, error) : error;
+  }
+}
+function plan(session, table, options, mods, view) {
+  const record = isRecord(options) ? options : {};
+  rejectKeys(record, OPTIONS, "page");
+  const indexed = indexes(session.schema).get(table);
+  if (indexed === undefined)
+    fail("OKM1120", `Table ${table} is not in the schema.`);
+  if (record.limit === undefined)
+    fail("OKM1101", "page() needs a limit.");
+  const size = readLimit(record.limit);
+  if (size < 1) {
+    throw new OkmError2("invalid", "page() limit must be at least 1.", { kind: "invalid" });
+  }
+  const keys = orderKeys(indexed, record.orderBy);
+  const signature = `${table}:${keys.map((key) => `${key.column.field}.${key.dir}.${key.nulls}`).join(",")}`;
+  const after = record.after === undefined || record.after === null ? undefined : keyset(keys, signature, record.after);
+  const wanted = selectedColumns(indexed, record.select);
+  const extra = keys.filter((key) => !wanted.includes(key.column)).map((key) => key.column.field);
+  const select = extra.length === 0 ? record.select : [...wanted.map((column) => column.field), ...extra];
+  const orderBy = {};
+  for (const key of keys)
+    orderBy[key.column.field] = { dir: key.dir, nulls: key.nulls };
+  const call = {
+    ...readCall("find", table, {
+      where: record.where,
+      select,
+      orderBy,
+      limit: size + 1,
+      include: record.include,
+      signal: record.signal,
+      timeout: record.timeout
+    }, undefined, session.scope, session.schema.model[table], session.schema, view),
+    ...after !== undefined ? { after } : {}
+  };
+  return readHandle(session, table, call, mods, async (compiled, rows) => {
+    const items = await decodeRows(compiled, rows, table);
+    const more = items.length > size;
+    const kept = more ? items.slice(0, size) : items;
+    const last = rows[size - 1];
+    const next = more && last !== undefined ? makeCursor(compiled, last, keys, signature) : null;
+    if (extra.length > 0) {
+      for (const item of kept) {
+        for (const field of extra)
+          delete item[field];
+      }
+    }
+    return { items: kept, next };
+  });
+}
+function orderKeys(table, orderBy) {
+  if (orderBy !== undefined && !isRecord(orderBy)) {
+    fail("OKM1120", "orderBy must be an object of fields.");
+  }
+  const keys = [];
+  for (const field of Object.keys(orderBy ?? {})) {
+    const column = table.columns.get(field);
+    if (column === undefined) {
+      throwNamed2("OKM1120", field, table.names, `Field ${field} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
+    }
+    keys.push({ column, ...parseOrder(field, orderBy?.[field]) });
+  }
+  if (table.model.primary.length === 0) {
+    fail("OKM1120", `page() needs a primary key on ${table.model.name} to break ties.`);
+  }
+  for (const field of table.model.primary) {
+    const column = table.columns.get(field);
+    if (column === undefined || keys.some((key) => key.column === column))
+      continue;
+    keys.push({ column, dir: "asc", nulls: "last" });
+  }
+  return keys;
+}
+function keyset(keys, signature, token) {
+  const values = readCursor(token, signature, keys.length);
+  return (sink, alias) => {
+    sink.mark(`k:${signature}:${values.map((value) => value === null ? "n" : "v").join("")}`);
+    let wrote = false;
+    for (let index = 0;index < keys.length; index += 1) {
+      const key = keys[index];
+      const value = values[index];
+      if (key === undefined || value === undefined)
+        continue;
+      if (value === null && key.nulls === "last")
+        continue;
+      sink.text(wrote ? " or (" : "(");
+      wrote = true;
+      for (let before = 0;before < index; before += 1) {
+        const prior = keys[before];
+        const held = values[before];
+        if (prior === undefined || held === undefined)
+          continue;
+        const ref = `${alias}.${quote(prior.column.sql)}`;
+        if (held === null) {
+          sink.text(`${ref} is null and `);
+        } else {
+          sink.text(`${ref} = `);
+          sink.param(held);
+          sink.text(" and ");
+        }
+      }
+      const ref = `${alias}.${quote(key.column.sql)}`;
+      if (value === null) {
+        sink.text(`${ref} is not null`);
+      } else {
+        sink.text(key.nulls === "last" ? `(${ref} ${compare(key)} ` : `${ref} ${compare(key)} `);
+        sink.param(value);
+        sink.text(key.nulls === "last" ? ` or ${ref} is null)` : "");
+      }
+      sink.text(")");
+    }
+    if (!wrote)
+      sink.text("false");
+  };
+}
+function compare(key) {
+  return key.dir === "asc" ? ">" : "<";
+}
+function makeCursor(plan, row, keys, signature) {
+  const values = keys.map((key) => {
+    const at = plan.outputs.fields.find((field) => field.key === key.column.field)?.at;
+    return at === undefined ? null : row[at] ?? null;
+  });
+  const bytes = new TextEncoder().encode(JSON.stringify([signature, ...values]));
+  let binary = "";
+  for (const byte of bytes)
+    binary += String.fromCharCode(byte);
+  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+}
+function readCursor(token, signature, count) {
+  let parsed;
+  if (typeof token === "string") {
+    try {
+      const binary = atob(token.replaceAll("-", "+").replaceAll("_", "/"));
+      const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+      parsed = JSON.parse(new TextDecoder().decode(bytes));
+    } catch {
+      parsed = undefined;
+    }
+  }
+  if (!Array.isArray(parsed) || typeof parsed[0] !== "string") {
+    fail("OKM1130", "after is not a cursor that page() returned.");
+  }
+  if (parsed[0] !== signature) {
+    fail("OKM1130", `The cursor was made for another order: ${parsed[0]}. This page orders by ${signature}.`);
+  }
+  const values = parsed.slice(1);
+  if (values.length !== count || !values.every((value) => value === null || typeof value === "string")) {
+    fail("OKM1130", "after is not a cursor that page() returned.");
+  }
+  return values;
+}
+export {
+  build
+};

package/dist/shared/{kprcwaha.js → eaxwrgby.js}

@@ -1,8 +1,9 @@
-import"./y9m15dfv.js";
+import"./d2whjz4k.js";
+import"./n442h54c.js";
 import {
   listTargets,
   loadConfig
-} from "./05w44d8g.js";
+} from "./5z4q2zda.js";
 
 // src/tooling/migrate/dev.ts
 import { mkdirSync } from "node:fs";
@@ -15,7 +16,7 @@ async function devProject(cwd) {
 `;
   const directory = join(cwd, config.out ?? ".okm", "dev-db");
   mkdirSync(directory, { recursive: true });
-  const { open } = await import("./8b04d28c.js");
+  const { open } = await import("./py3nh7jy.js");
   const pool = await open({ dataDir: directory });
   try {
     await pool.execute("select 1");