okmodel 0.1.0 → 0.2.1

package/dist/shared/3a5ne750.js

@@ -0,0 +1,158 @@
+import {
+  ColumnBuilder2
+} from "./dd4f8mnx.js";
+import {
+  definition
+} from "./xatfg0gn.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/4b9da9d7.js

@@ -0,0 +1,138 @@
+import {
+  assertOperatorFits,
+  sqlType,
+  assertNoControl,
+  assertBoundText,
+  assertRegconfig,
+  textArray
+} from "./zt8y0wzb.js";
+import {
+  installOperatorSql,
+  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;
+  }
+  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(")");
+}
+installOperatorSql(emitStructured);

package/dist/shared/4e4c6vq2.js

@@ -0,0 +1,62 @@
+// src/contracts/catalog/types.ts
+var OWNERS2 = ["managed", "external", "ignored"];
+var OBJECT_KINDS2 = [
+  "table",
+  "column",
+  "index",
+  "constraint",
+  "sequence",
+  "view",
+  "materializedView",
+  "type",
+  "function",
+  "trigger",
+  "policy",
+  "extension",
+  "role",
+  "grant",
+  "defaultPrivilege"
+];
+var BUILT_KINDS2 = ["table", "column", "index", "constraint", "sequence", "type"];
+var OBJECT_OPERATIONS2 = [
+  "create",
+  "replace",
+  "alter",
+  "drop",
+  "recreateWithDependents"
+];
+var KIND_OPERATIONS2 = {
+  table: ["create", "alter", "drop", "recreateWithDependents"],
+  column: ["create", "alter", "drop", "recreateWithDependents"],
+  index: ["create", "drop", "recreateWithDependents"],
+  constraint: ["create", "alter", "drop", "recreateWithDependents"],
+  sequence: ["create", "alter", "drop"],
+  view: ["create", "replace", "drop", "recreateWithDependents"],
+  materializedView: ["create", "drop", "recreateWithDependents"],
+  type: ["create", "alter", "drop"],
+  function: ["create", "replace", "drop", "recreateWithDependents"],
+  trigger: ["create", "drop", "recreateWithDependents"],
+  policy: ["create", "alter", "drop"],
+  extension: ["create", "alter", "drop"],
+  role: ["create", "alter"],
+  grant: ["create", "drop"],
+  defaultPrivilege: ["create", "alter", "drop"]
+};
+var REFERENTIAL_ACTIONS = [
+  "cascade",
+  "no action",
+  "restrict",
+  "set default",
+  "set null"
+];
+function referentialAction(value) {
+  for (const action of REFERENTIAL_ACTIONS) {
+    if (action === value) {
+      return action;
+    }
+  }
+  return;
+}
+var CATALOG_VERSION2 = 1;
+
+export { OWNERS2, OBJECT_KINDS2, BUILT_KINDS2, OBJECT_OPERATIONS2, KIND_OPERATIONS2, REFERENTIAL_ACTIONS, referentialAction, CATALOG_VERSION2 };