okmodel 0.1.1 → 0.3.0

package/dist/shared/9m80mkac.js

@@ -0,0 +1,158 @@
+import {
+  ColumnBuilder2
+} from "./c9z5g0fm.js";
+import {
+  definition
+} from "./tmbdywx0.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/runtime/validate/places.ts
+function assertValidation(schema) {
+  const record = schema;
+  const tables = record.tables;
+  if (tables === undefined)
+    return;
+  for (const item of tables)
+    validationGate(record.validation, item);
+}
+function validationGate(schemaFlag, table) {
+  return buildGate(schemaFlag, table);
+}
+function writeWouldValidate(schemaFlag, table, options) {
+  if (options.validate === false)
+    return false;
+  const setting = tableSetting(readSetting(schemaFlag, "schema()"), table.options);
+  if (setting.enabled)
+    return true;
+  const section = table.options;
+  if (section?.validate !== undefined)
+    return true;
+  for (const builder of Object.values(table.columns)) {
+    if (builder instanceof ColumnBuilder2 && builder.state.validate !== undefined)
+      return true;
+  }
+  return false;
+}
+function buildGate(schemaFlag, table) {
+  const setting = tableSetting(readSetting(schemaFlag, "schema()"), table.options);
+  const section = readSection(table.name, table.options);
+  if (setting.style === "inline" && section.rowPresent)
+    conflict(table.name, "$row");
+  const fields = {};
+  const required = [];
+  const notNull = [];
+  const pick = {};
+  const names = new Set;
+  for (const [field, builder] of Object.entries(table.columns)) {
+    if (!(builder instanceof ColumnBuilder2))
+      continue;
+    names.add(field);
+    const inline = builder.state.validate?.rules;
+    const named = Object.hasOwn(section.fields, field) ? section.fields[field] : undefined;
+    const rules = takeRules(table.name, field, inline, named, setting.style);
+    if (rules !== undefined)
+      fields[field] = rules;
+    const state = builder.state;
+    const writable = state.guarded !== true && state.omitWrite !== true && state.generated === undefined;
+    if (setting.enabled && writable) {
+      if (!state.nullable && state.hasDefault !== true)
+        required.push(field);
+      if (!state.nullable)
+        notNull.push(field);
+      if (state.picklist !== undefined)
+        pick[field] = state.picklist.values;
+    }
+  }
+  for (const field of Object.keys(section.fields)) {
+    if (!names.has(field))
+      definition(`Table ${table.name} validate.${field} is not a column.`);
+  }
+  if (!setting.enabled)
+    return;
+  return { onRead: setting.onRead, row: section.row, fields, required, notNull, pick };
+}
+function readSetting(value, where) {
+  if (value === undefined || value === false)
+    return { enabled: false, onRead: false, style: undefined };
+  if (value === true)
+    return { enabled: true, onRead: false, style: undefined };
+  if (isPlain(value)) {
+    return {
+      enabled: value.enabled === undefined ? true : value.enabled === true,
+      onRead: value.onRead === true,
+      style: readStyle(value.style)
+    };
+  }
+  definition(`${where} validation must be a boolean or { enabled, onRead, style }.`);
+}
+function tableSetting(schemaSetting, options) {
+  const value = options === undefined ? undefined : options.validation;
+  if (value === undefined)
+    return schemaSetting;
+  if (value === true)
+    return { enabled: true, onRead: schemaSetting.onRead, style: schemaSetting.style };
+  if (value === false)
+    return { enabled: false, onRead: schemaSetting.onRead, style: schemaSetting.style };
+  if (isPlain(value)) {
+    return {
+      enabled: value.enabled === undefined ? true : value.enabled === true,
+      onRead: value.onRead === undefined ? schemaSetting.onRead : value.onRead === true,
+      style: value.style === undefined ? schemaSetting.style : readStyle(value.style)
+    };
+  }
+  definition("table() validation must be a boolean or { enabled, onRead, style }.");
+}
+function readStyle(value) {
+  if (value === undefined)
+    return;
+  if (value === "inline" || value === "section")
+    return value;
+  definition("validation.style must be inline or section.");
+}
+function readSection(table, options) {
+  const validate = options === undefined ? undefined : options.validate;
+  if (validate === undefined)
+    return { fields: {}, row: [], rowPresent: false };
+  if (!isPlain(validate)) {
+    definition(`Table ${table} option validate must be { field: rules, $row: rules }.`);
+  }
+  const fields = {};
+  let row = [];
+  let rowPresent = false;
+  for (const key of Object.keys(validate)) {
+    const item = validate[key];
+    if (!Array.isArray(item))
+      definition(`Table ${table} validate.${key} must be a list of rules.`);
+    if (key === "$row") {
+      row = item;
+      rowPresent = true;
+    } else
+      fields[key] = item;
+  }
+  return { fields, row, rowPresent };
+}
+function takeRules(table, field, inline, section, style) {
+  const hasInline = inline !== undefined;
+  const hasSection = section !== undefined;
+  if (hasInline && hasSection || style === "inline" && hasSection || style === "section" && hasInline) {
+    conflict(table, field);
+  }
+  if (hasInline && inline.length > 0)
+    return inline;
+  if (hasSection && section.length > 0)
+    return section;
+  return;
+}
+function conflict(table, field) {
+  throw new OkmError2("OKM1030", `Field ${table}.${field} is validated in two places. Keep the column rules or the validate section.`, {
+    ...field === "$row" ? {} : { columns: [field] },
+    fix: { summary: "Keep one validation for the field." }
+  });
+}
+function isPlain(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export { assertValidation, validationGate, writeWouldValidate };

package/dist/shared/9x25fxhc.js

@@ -0,0 +1,150 @@
+import {
+  staticNamespace2,
+  assertNamespace2,
+  normaliseEdges,
+  assertProvenance
+} from "./t4tbsy9h.js";
+import {
+  assertIdentifier2
+} from "./nfzc5z0w.js";
+import {
+  catalogError2
+} from "./52szzakm.js";
+
+// src/contracts/catalog/routine.ts
+var VOLATILITY = new Set(["volatile", "stable", "immutable"]);
+var SECURITY = new Set(["invoker", "definer"]);
+var TIMING = new Set(["before", "after", "instead"]);
+var LEVEL = new Set(["row", "statement"]);
+var EVENT_ORDER = ["insert", "update", "delete", "truncate"];
+var TYPE_TEXT = /^[A-Za-z][A-Za-z0-9_ ]*(\(\d+(,\s*\d+)?\))?(\[\])*$/;
+function functionObject(input) {
+  assertIdentifier2(input.name, "function");
+  const namespace = input.namespace ?? staticNamespace2("public");
+  assertNamespace2(namespace);
+  assertProvenance(input.provenance);
+  if (input.language !== "sql" && input.language !== "plpgsql") {
+    catalogError2("OKM1020", `Function ${input.name} language must be sql or plpgsql.`);
+  }
+  const volatility = input.volatility ?? "volatile";
+  if (!VOLATILITY.has(volatility)) {
+    catalogError2("OKM1020", `Function ${input.name} volatility ${volatility} is not supported.`);
+  }
+  const security = input.security ?? "invoker";
+  if (!SECURITY.has(security)) {
+    catalogError2("OKM1020", `Function ${input.name} security ${security} is not supported.`);
+  }
+  assertTypeName(input.returns, `function ${input.name} return type`);
+  const args = (input.arguments ?? []).map((argument) => readArgument(input.name, argument));
+  if (input.body.length === 0) {
+    catalogError2("OKM1020", `Function ${input.name} needs a body.`);
+  }
+  const atomic = input.atomic === true;
+  if (atomic && input.language !== "sql") {
+    catalogError2("OKM1020", `Function ${input.name} BEGIN ATOMIC needs language sql.`);
+  }
+  if (input.searchPath !== undefined && input.searchPath.trim().length === 0) {
+    catalogError2("OKM1020", `Function ${input.name} search_path is empty.`);
+  }
+  const definition = {
+    arguments: args,
+    returns: input.returns,
+    language: input.language,
+    volatility,
+    security,
+    body: input.body,
+    ...input.searchPath !== undefined ? { searchPath: input.searchPath } : {},
+    ...atomic ? { atomic: true } : {}
+  };
+  return {
+    kind: "function",
+    identity: {
+      kind: "function",
+      namespace,
+      name: input.name,
+      argTypes: args.map((arg) => arg.type)
+    },
+    owner: input.owner ?? "managed",
+    definition,
+    dependencies: normaliseEdges(input.dependencies ?? []),
+    provenance: input.provenance
+  };
+}
+function triggerObject(input) {
+  assertIdentifier2(input.name, "trigger");
+  assertNamespace2(input.parent.namespace);
+  assertIdentifier2(input.parent.name, "trigger table");
+  assertProvenance(input.provenance);
+  if (!TIMING.has(input.timing)) {
+    catalogError2("OKM1020", `Trigger ${input.name} timing ${input.timing} is not supported.`);
+  }
+  if (!LEVEL.has(input.level)) {
+    catalogError2("OKM1020", `Trigger ${input.name} level ${input.level} is not supported.`);
+  }
+  const events = EVENT_ORDER.filter((event) => input.events.includes(event));
+  if (events.length === 0) {
+    catalogError2("OKM1020", `Trigger ${input.name} needs an event.`);
+  }
+  const updateOf = input.updateOf === undefined ? undefined : [...input.updateOf];
+  if (updateOf !== undefined) {
+    if (!events.includes("update")) {
+      catalogError2("OKM1020", `Trigger ${input.name} lists UPDATE OF columns without an update event.`);
+    }
+    if (input.level !== "row") {
+      catalogError2("OKM1020", `Trigger ${input.name} UPDATE OF columns need level row.`);
+    }
+    for (const column of updateOf)
+      assertIdentifier2(column, "trigger column");
+  }
+  assertIdentifier2(input.calls.name, "trigger function");
+  assertNamespace2(input.calls.namespace);
+  for (const typeName of input.calls.argTypes)
+    assertTypeName(typeName, `trigger ${input.name}`);
+  const edges = [
+    { kind: "table", namespace: input.parent.namespace, name: input.parent.name },
+    {
+      kind: "function",
+      namespace: input.calls.namespace,
+      name: input.calls.name,
+      argTypes: input.calls.argTypes
+    },
+    ...(updateOf ?? []).map((column) => ({
+      kind: "column",
+      parent: input.parent,
+      name: column
+    })),
+    ...input.dependencies ?? []
+  ];
+  const definition = {
+    timing: input.timing,
+    events,
+    level: input.level,
+    calls: {
+      namespace: input.calls.namespace,
+      name: input.calls.name,
+      argTypes: [...input.calls.argTypes]
+    },
+    ...updateOf !== undefined && updateOf.length > 0 ? { updateOf } : {},
+    ...input.when !== undefined && input.when.length > 0 ? { when: input.when } : {}
+  };
+  return {
+    kind: "trigger",
+    identity: { kind: "trigger", parent: input.parent, name: input.name },
+    owner: input.owner ?? "managed",
+    definition,
+    dependencies: normaliseEdges(edges),
+    provenance: input.provenance
+  };
+}
+function readArgument(fn, argument) {
+  assertIdentifier2(argument.name, `function ${fn} argument`);
+  assertTypeName(argument.type, `function ${fn} argument ${argument.name}`);
+  return { name: argument.name, type: argument.type };
+}
+function assertTypeName(typeName, role) {
+  if (!TYPE_TEXT.test(typeName)) {
+    catalogError2("OKM1020", `${role} ${typeName} is not a type name.`);
+  }
+}
+
+export { functionObject, triggerObject };

package/dist/shared/a5sxz52y.js

@@ -0,0 +1,13 @@
+// src/runtime/safety-hook.ts
+var hook;
+function safetyInstalled() {
+  return hook !== undefined;
+}
+function installSafetyHook(next) {
+  hook = next;
+}
+function runSafety(contributions, hatches) {
+  hook?.(contributions, hatches);
+}
+
+export { safetyInstalled, installSafetyHook, runSafety };

package/dist/shared/axhk06q1.js

@@ -0,0 +1,156 @@
+import {
+  assertOperatorFits,
+  sqlType,
+  assertNoControl,
+  assertBoundText,
+  assertRegconfig,
+  textArray
+} from "./n7mcc1gk.js";
+import {
+  installOperatorSql,
+  quote,
+  isRecord,
+  fail
+} from "./xrfnq5k8.js";
+import {
+  isOperator,
+  operatorName,
+  operatorValue
+} from "./cn0n68ft.js";
+
+// src/runtime/operator-sql.ts
+function emitStructured(column, ref, name, value, sink) {
+  if (name === "contains" || name === "containedBy" || name === "overlaps") {
+    emitContainment(column, ref, name, value, sink);
+    return;
+  }
+  if (name === "hasKey" || name === "hasAnyKey") {
+    emitJsonKey(column, ref, name, value, sink);
+    return;
+  }
+  if (name === "path") {
+    emitPath(column, ref, value, sink);
+    return;
+  }
+  if (name === "matches") {
+    emitMatches(column, ref, value, sink);
+    return;
+  }
+  if (name === "similar" || name === "wordSimilar") {
+    emitTrigram(column, ref, name, value, sink);
+    return;
+  }
+  assertOperatorFits(column, name);
+  fail("OKM1121", `${name} is not a value operator on ${column.field}. Use has, none, or every on a relation.`);
+}
+function emitContainment(column, ref, name, value, sink) {
+  assertOperatorFits(column, name);
+  const op = name === "contains" ? " @> " : name === "containedBy" ? " <@ " : " && ";
+  sink.text(ref);
+  sink.text(op);
+  sink.param(column.encode(value));
+  sink.text("::");
+  sink.text(sqlType(column.dataType, column));
+}
+function emitJsonKey(column, ref, name, value, sink) {
+  assertOperatorFits(column, name);
+  if (name === "hasKey") {
+    if (typeof value !== "string")
+      fail("OKM1121", `hasKey on ${column.field} needs a key.`);
+    assertBoundText(value, `key on ${column.field}`);
+    sink.text("jsonb_exists(");
+    sink.text(ref);
+    sink.text(", ");
+    sink.param(value);
+    sink.text(")");
+    return;
+  }
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    fail("OKM1121", `hasAnyKey on ${column.field} needs a list of keys.`);
+  }
+  sink.text("jsonb_exists_any(");
+  sink.text(ref);
+  sink.text(", ");
+  sink.param(textArray(value, `key on ${column.field}`));
+  sink.text("::text[])");
+}
+function emitPath(column, ref, value, sink) {
+  assertOperatorFits(column, "path");
+  if (!isRecord(value) || !Array.isArray(value.segments) || !isOperator(value.op)) {
+    fail("OKM1121", `path on ${column.field} needs segments and a comparison.`);
+  }
+  const segments = value.segments;
+  if (segments.length === 0 || segments.some((item) => typeof item !== "string")) {
+    fail("OKM1121", `path on ${column.field} needs a list of segments.`);
+  }
+  const opName = operatorName(value.op);
+  if (opName !== "eq" && opName !== "lt" && opName !== "lte" && opName !== "gt" && opName !== "gte") {
+    fail("OKM1121", `path on ${column.field} compares with eq, lt, lte, gt, or gte.`);
+  }
+  const operand = operatorValue(value.op);
+  const cast = pathCast(column, operand);
+  const sql = opName === "eq" ? " = " : opName === "lt" ? " < " : opName === "lte" ? " <= " : opName === "gt" ? " > " : " >= ";
+  sink.text("(");
+  sink.text(ref);
+  sink.text(" #>> ");
+  sink.param(textArray(segments, `path on ${column.field}`));
+  sink.text("::text[])::");
+  sink.text(cast);
+  sink.text(sql);
+  sink.param(pathParam(operand));
+}
+function pathCast(column, operand) {
+  if (typeof operand === "number")
+    return "numeric";
+  if (typeof operand === "boolean")
+    return "boolean";
+  if (typeof operand === "string")
+    return "text";
+  fail("OKM1121", `path on ${column.field} compares a string, number, or boolean.`);
+}
+function pathParam(operand) {
+  if (typeof operand === "number")
+    return String(operand);
+  if (typeof operand === "boolean")
+    return operand ? "true" : "false";
+  if (typeof operand === "string")
+    return operand;
+  return "";
+}
+function emitMatches(column, ref, value, sink) {
+  assertOperatorFits(column, "matches");
+  if (!isRecord(value) || typeof value.query !== "string") {
+    fail("OKM1121", `matches on ${column.field} needs search text.`);
+  }
+  assertNoControl(value.query, `matches on ${column.field}`);
+  const mode = value.mode ?? "websearch";
+  const fn = mode === "websearch" ? "websearch_to_tsquery" : mode === "plain" ? "plainto_tsquery" : mode === "phrase" ? "phraseto_tsquery" : undefined;
+  if (fn === undefined) {
+    fail("OKM1121", `matches on ${column.field} mode must be websearch, plain, or phrase.`);
+  }
+  sink.text(ref);
+  sink.text(" @@ ");
+  sink.text(fn);
+  sink.text("(");
+  if (typeof value.config === "string") {
+    assertRegconfig(value.config);
+    sink.param(value.config);
+    sink.text("::regconfig, ");
+  }
+  sink.param(value.query);
+  sink.text(")");
+}
+function emitTrigram(column, ref, name, value, sink) {
+  if (!isRecord(value) || typeof value.query !== "string" || typeof value.schema !== "string") {
+    fail("OKM1121", `${name} on ${column.field} needs query text.`);
+  }
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value.schema)) {
+    fail("OKM1121", `${name} on ${column.field} needs an extension schema name.`);
+  }
+  sink.text(ref);
+  sink.text(" operator(");
+  sink.text(quote(value.schema));
+  sink.text(name === "similar" ? ".%) " : ".<%) ");
+  sink.param(value.query);
+}
+installOperatorSql(emitStructured);

package/dist/shared/{dynq16vb.js → b066g80h.js}

@@ -2,10 +2,10 @@ import {
   DriverError2,
   outcomeUnknown2,
   mapDriverError2
-} from "./hd293j9g.js";
+} from "./kyxb62mc.js";
 import {
-  isConnectionFailure
-} from "./ngk8gj61.js";
+  isConnectionLost
+} from "./tbszx8mz.js";
 
 // src/adapters/pg/batch.ts
 var savepointIds = 0;
@@ -21,13 +21,14 @@ async function transaction(session, statements, watch) {
     try {
       await control(session, "COMMIT", watch);
     } catch (error) {
-      if (isConnectionFailure(error))
+      if (isConnectionLost(error))
         throw outcomeUnknown2(error);
       throw stamp(error, null);
     }
     return results;
   } catch (error) {
-    await rollback(session);
+    if (!isConnectionLost(error))
+      await rollback(session);
     throw error;
   }
 }
@@ -40,7 +41,8 @@ async function savepoint(session, statements, watch) {
     await control(session, `RELEASE SAVEPOINT ${name}`, watch);
     return results;
   } catch (error) {
-    await rollback(session, `ROLLBACK TO SAVEPOINT ${name}`);
+    if (!isConnectionLost(error))
+      await rollback(session, `ROLLBACK TO SAVEPOINT ${name}`);
     throw error;
   }
 }