okmodel 0.0.0 → 0.1.1

package/dist/shared/ycwz42az.js

@@ -0,0 +1,412 @@
+// src/contracts/nearest.ts
+function nearestName2(input, candidates) {
+  if (input.length === 0 || candidates.length === 0)
+    return;
+  const limit = input.length <= 4 ? 1 : input.length <= 12 ? 2 : 3;
+  let width = 0;
+  for (const candidate of candidates) {
+    if (candidate.length > width)
+      width = candidate.length;
+  }
+  const prev = new Uint16Array(width + 1);
+  const next = new Uint16Array(width + 1);
+  let best;
+  let bestDistance = limit;
+  for (const candidate of candidates) {
+    if (candidate === input)
+      continue;
+    const gap = candidate.length > input.length ? candidate.length - input.length : input.length - candidate.length;
+    if (gap > bestDistance)
+      continue;
+    const distance = editDistance(input, candidate, bestDistance, prev, next);
+    if (distance === undefined)
+      continue;
+    if (best === undefined || distance < bestDistance || distance === bestDistance && candidate < best) {
+      best = candidate;
+      bestDistance = distance;
+    }
+  }
+  return best;
+}
+function editDistance(left, right, cap, prev, next) {
+  const leftLength = left.length;
+  const rightLength = right.length;
+  if (leftLength === 0)
+    return rightLength <= cap ? rightLength : undefined;
+  if (rightLength === 0)
+    return leftLength <= cap ? leftLength : undefined;
+  for (let column = 0;column <= rightLength; column += 1)
+    prev[column] = column;
+  for (let row = 1;row <= leftLength; row += 1) {
+    next[0] = row;
+    let rowBest = row;
+    const leftCode = left.charCodeAt(row - 1);
+    for (let column = 1;column <= rightLength; column += 1) {
+      const cost = sameLetter(leftCode, right.charCodeAt(column - 1)) ? 0 : 1;
+      const deletion = (prev[column] ?? 0) + 1;
+      const insertion = (next[column - 1] ?? 0) + 1;
+      const substitution = (prev[column - 1] ?? 0) + cost;
+      let value = deletion < insertion ? deletion : insertion;
+      if (substitution < value)
+        value = substitution;
+      next[column] = value;
+      if (value < rowBest)
+        rowBest = value;
+    }
+    if (rowBest > cap)
+      return;
+    for (let column = 0;column <= rightLength; column += 1)
+      prev[column] = next[column] ?? 0;
+  }
+  const distance = prev[rightLength] ?? cap + 1;
+  return distance <= cap ? distance : undefined;
+}
+function sameLetter(left, right) {
+  if (left === right)
+    return true;
+  const leftFold = left >= 65 && left <= 90 ? left + 32 : left;
+  const rightFold = right >= 65 && right <= 90 ? right + 32 : right;
+  return leftFold === rightFold;
+}
+
+// src/contracts/error.ts
+var CATALOG_CODES2 = [
+  "OKM1020",
+  "OKM1021",
+  "OKM1022",
+  "OKM1023",
+  "OKM1026",
+  "OKM1027",
+  "OKM1122"
+];
+var COLUMN_CODES2 = ["OKM1060", "OKM1061", "OKM1210"];
+var ERROR_KINDS2 = [
+  "invalid",
+  "not_null",
+  "check",
+  "foreign_key",
+  "unique",
+  "exclusion",
+  "conflict",
+  "not_found",
+  "not_unique",
+  "forbidden",
+  "serialization",
+  "deadlock",
+  "lock_timeout",
+  "timeout",
+  "cancelled",
+  "unavailable",
+  "schema_drift",
+  "driver",
+  "read_only",
+  "outcome_unknown"
+];
+var ERROR_CATEGORIES2 = [
+  "input",
+  "conflict",
+  "not_found",
+  "forbidden",
+  "transient",
+  "internal"
+];
+var NO_COLUMNS = [];
+var NO_FIELDS = {};
+var DEFAULT_STATUS = {
+  input: 422,
+  conflict: 409,
+  not_found: 404,
+  forbidden: 403,
+  transient: 503,
+  internal: 500
+};
+var CATEGORY_OF = {
+  invalid: "input",
+  not_null: "input",
+  check: "input",
+  foreign_key: "input",
+  unique: "conflict",
+  exclusion: "conflict",
+  conflict: "conflict",
+  not_found: "not_found",
+  not_unique: "not_found",
+  forbidden: "forbidden",
+  serialization: "transient",
+  deadlock: "transient",
+  lock_timeout: "transient",
+  timeout: "transient",
+  cancelled: "transient",
+  unavailable: "transient",
+  schema_drift: "internal",
+  driver: "internal",
+  read_only: "internal",
+  outcome_unknown: "internal"
+};
+
+class OkmError2 extends Error {
+  code;
+  kind;
+  category;
+  retryable;
+  fix;
+  table;
+  columns;
+  constraint;
+  sqlstate;
+  batchIndex;
+  fieldReason;
+  #fields;
+  #values;
+  #http;
+  get summary() {
+    return this.message;
+  }
+  constructor(code, message, options) {
+    const cause = options?.cause;
+    super(message, cause === undefined ? undefined : { cause });
+    this.name = "OkmError";
+    this.code = code;
+    const kind = options?.kind ?? kindFromCode(code);
+    this.kind = kind;
+    this.category = CATEGORY_OF[kind];
+    this.retryable = options?.retryable ?? defaultRetryable(kind);
+    this.fix = options?.fix ?? { summary: defaultFix(kind) };
+    this.table = options?.table;
+    const columns = options?.columns;
+    this.columns = columns === undefined || columns.length === 0 ? NO_COLUMNS : columns;
+    this.constraint = options?.constraint;
+    this.sqlstate = options?.sqlstate;
+    this.batchIndex = options?.batchIndex === undefined ? null : options.batchIndex;
+    this.fieldReason = options?.fieldReason ?? kind;
+    this.#values = options?.includeValues === true ? options.values : undefined;
+    this.#http = options?.http;
+  }
+  static from(error) {
+    if (error instanceof OkmError2)
+      return error;
+    if (isDriverError(error))
+      return fromDriver(error);
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return new OkmError2("driver", stripRowValues(message), { kind: "driver", cause: error });
+  }
+  static is(error, kind, table) {
+    if (!(error instanceof OkmError2) || error.kind !== kind)
+      return false;
+    return table === undefined || error.table === table;
+  }
+  fields() {
+    const cached = this.#fields;
+    if (cached !== undefined)
+      return cached;
+    if (this.columns.length === 0) {
+      this.#fields = NO_FIELDS;
+      return NO_FIELDS;
+    }
+    const built = {};
+    const reason = this.fieldReason;
+    for (const column of this.columns)
+      built[column] = reason;
+    this.#fields = built;
+    return built;
+  }
+  values() {
+    return this.#values;
+  }
+  toHttp(statuses) {
+    const chosen = statuses ?? this.#http;
+    const override = chosen?.[this.category];
+    return {
+      status: override ?? DEFAULT_STATUS[this.category],
+      body: {
+        code: this.code,
+        reason: this.message,
+        fields: this.fields()
+      }
+    };
+  }
+  log() {
+    return {
+      name: "OkmError",
+      code: this.code,
+      kind: this.kind,
+      category: this.category,
+      summary: this.message,
+      retryable: this.retryable,
+      batchIndex: this.batchIndex,
+      fix: this.fix,
+      fields: this.fields(),
+      ...this.table !== undefined ? { table: this.table } : {},
+      ...this.columns.length > 0 ? { columns: this.columns } : {},
+      ...this.constraint !== undefined ? { constraint: this.constraint } : {},
+      ...this.sqlstate !== undefined ? { sqlstate: this.sqlstate } : {}
+    };
+  }
+  match(handlers) {
+    const handler = handlers[this.category];
+    if (handler !== undefined)
+      return handler(this);
+    return handlers._(this);
+  }
+}
+function safe2(pending) {
+  return pending.then((value) => ({ ok: true, value }), (error) => ({ ok: false, error: OkmError2.from(error) }));
+}
+function catalogError2(code, message, options) {
+  throw new OkmError2(code, message, options);
+}
+function throwNamed2(code, input, candidates, message) {
+  const suggestion = nearestName2(input, candidates);
+  if (suggestion === undefined)
+    throw new OkmError2(code, message);
+  throw new OkmError2(code, `${message} Did you mean \`${suggestion}\`?`, {
+    fix: { summary: `Use \`${suggestion}\`.`, suggestion }
+  });
+}
+function stripRowValues(text) {
+  let result = "";
+  for (let index = 0;index < text.length; index += 1) {
+    if (text.charCodeAt(index) === 61 && text.charCodeAt(index + 1) === 40) {
+      const end = matchingParen(text, index + 1);
+      if (end !== undefined) {
+        index = end;
+        continue;
+      }
+    }
+    if (startsAt(text, index, "contains (")) {
+      const open = index + "contains ".length;
+      const end = matchingParen(text, open);
+      if (end !== undefined) {
+        result += "contains (…)";
+        index = end;
+        continue;
+      }
+    }
+    result += text.charAt(index);
+  }
+  return result;
+}
+function kindFromCode(code) {
+  if (isErrorKind(code))
+    return code;
+  switch (code) {
+    case "OKM1401":
+      return "outcome_unknown";
+    case "OKM1846":
+      return "timeout";
+    case "OKM1520":
+      return "schema_drift";
+    default:
+      return "invalid";
+  }
+}
+function isErrorKind(code) {
+  switch (code) {
+    case "invalid":
+    case "not_null":
+    case "check":
+    case "foreign_key":
+    case "unique":
+    case "exclusion":
+    case "conflict":
+    case "not_found":
+    case "not_unique":
+    case "forbidden":
+    case "serialization":
+    case "deadlock":
+    case "lock_timeout":
+    case "timeout":
+    case "cancelled":
+    case "unavailable":
+    case "schema_drift":
+    case "driver":
+    case "read_only":
+    case "outcome_unknown":
+      return true;
+    default:
+      return false;
+  }
+}
+function defaultRetryable(kind) {
+  if (kind === "cancelled" || kind === "outcome_unknown")
+    return false;
+  return CATEGORY_OF[kind] === "transient";
+}
+function defaultFix(kind) {
+  switch (kind) {
+    case "cancelled":
+      return "Do not retry. The caller aborted the call.";
+    case "outcome_unknown":
+      return "Check whether the write landed, using an idempotency key, before retrying.";
+    case "timeout":
+    case "serialization":
+    case "deadlock":
+    case "lock_timeout":
+    case "unavailable":
+      return "Retry the call.";
+    case "unique":
+    case "exclusion":
+    case "conflict":
+      return "Change the conflicting value, or update the existing row.";
+    case "not_null":
+      return "Provide a value for the column.";
+    case "check":
+    case "invalid":
+      return "Change the value so it passes the check.";
+    case "foreign_key":
+      return "Use a key that exists, or insert the referenced row first.";
+    case "not_found":
+      return "Look up a row that exists.";
+    case "not_unique":
+      return "Narrow the filter so it matches one row.";
+    case "forbidden":
+      return "Use a role that is allowed to perform this operation.";
+    case "read_only":
+      return "Run the write on the primary.";
+    case "schema_drift":
+      return "Apply the migrations that match this build.";
+    case "driver":
+      return "Read the summary and correct the call.";
+  }
+}
+function isDriverError(error) {
+  return error instanceof Error && error.name === "DriverError";
+}
+function fromDriver(error) {
+  const kind = error.kind ?? "driver";
+  const code = kind === "outcome_unknown" ? "OKM1401" : kind;
+  const columns = error.column === undefined || error.column.length === 0 ? undefined : [error.column];
+  return new OkmError2(code, stripRowValues(error.message), {
+    kind,
+    ...error.table !== undefined ? { table: error.table } : {},
+    ...columns !== undefined ? { columns } : {},
+    ...error.constraint !== undefined ? { constraint: error.constraint } : {},
+    ...error.sqlstate !== undefined ? { sqlstate: error.sqlstate } : {},
+    ...error.batchIndex !== undefined ? { batchIndex: error.batchIndex } : {},
+    cause: error.cause ?? error
+  });
+}
+function matchingParen(text, open) {
+  let depth = 0;
+  for (let index = open;index < text.length; index += 1) {
+    const code = text.charCodeAt(index);
+    if (code === 40)
+      depth += 1;
+    else if (code === 41) {
+      depth -= 1;
+      if (depth === 0)
+        return index;
+    }
+  }
+  return;
+}
+function startsAt(text, index, needle) {
+  if (index + needle.length > text.length)
+    return false;
+  for (let offset = 0;offset < needle.length; offset += 1) {
+    if (text.charCodeAt(index + offset) !== needle.charCodeAt(offset))
+      return false;
+  }
+  return true;
+}
+
+export { nearestName2, CATALOG_CODES2, COLUMN_CODES2, ERROR_KINDS2, ERROR_CATEGORIES2, OkmError2, safe2, catalogError2, throwNamed2, stripRowValues, matchingParen };

package/dist/shared/yd1kzwn2.js

@@ -0,0 +1,148 @@
+import {
+  projectExpr,
+  quote,
+  list,
+  isRecord,
+  fail
+} from "./rgs0st28.js";
+import {
+  throwNamed2
+} from "./ycwz42az.js";
+
+// src/runtime/conflict.ts
+function readConflict(table, value) {
+  if (value === undefined || value === "error")
+    return;
+  if (value === "ignore")
+    return { kind: "ignore", columns: [], update: [] };
+  if (!isRecord(value)) {
+    fail("OKM1120", 'onConflict must be "error", "ignore", { on, update }, or { on, return: true }.');
+  }
+  const keys = Object.keys(value);
+  const update = value.update;
+  const ret = value.return;
+  if (update !== undefined && ret !== undefined) {
+    fail("OKM1120", "onConflict takes update or return, not both.");
+  }
+  if (ret === true) {
+    rejectConflictKeys(keys, ["on", "return"]);
+    return { kind: "return", columns: uniqueColumns(table, value.on), update: [] };
+  }
+  if (update !== undefined) {
+    rejectConflictKeys(keys, ["on", "update"]);
+    return {
+      kind: "update",
+      columns: uniqueColumns(table, value.on),
+      update: updateColumns(table, update)
+    };
+  }
+  fail("OKM1120", 'onConflict must be "error", "ignore", { on, update }, or { on, return: true }.');
+}
+function finishInsert(head, returning, params, plan, table, returningColumns, keys) {
+  if (plan.kind === "ignore") {
+    return { text: `${head} on conflict do nothing${returning}`, params: [...params] };
+  }
+  const target = plan.columns.map((column) => quote(column.sql)).join(", ");
+  if (plan.kind === "update") {
+    const set = plan.update.map((column) => `${quote(column.sql)} = excluded.${quote(column.sql)}`).join(", ");
+    return {
+      text: `${head} on conflict (${target}) do update set ${set}${returning}`,
+      params: [...params]
+    };
+  }
+  return firstOrCreate(head, returning, params, plan.columns, table, returningColumns, keys);
+}
+function firstOrCreate(head, returning, params, keys, table, returningColumns, keyRows) {
+  const next = [...params];
+  const tuples = [];
+  for (const row of keyRows) {
+    const slots = [];
+    for (let index = 0;index < keys.length; index += 1) {
+      const column = keys[index];
+      if (column === undefined)
+        continue;
+      next.push(row[index] ?? null);
+      slots.push(`$${String(next.length)}::${column.dataType}`);
+    }
+    tuples.push(keys.length === 1 ? slots[0] ?? "null" : `(${slots.join(", ")})`);
+  }
+  const keyList = keys.map((column) => quote(column.sql)).join(", ");
+  const left = keys.length === 1 ? `t.${quote(keys[0]?.sql ?? "")}` : `(${keys.map((column) => `t.${quote(column.sql)}`).join(", ")})`;
+  const names = returningColumns.map((column) => quote(column.field)).join(", ");
+  const fromTable = returningColumns.map((column) => projectExpr(`t.${quote(column.sql)}`, column.dataType)).join(", ");
+  const match = keys.map((column) => `ins.${quote(column.field)} = t.${quote(column.sql)}`).join(" and ");
+  const text = `with ins(${names}) as (${head} on conflict (${keyList}) do nothing${returning}) select ${names} from ins union all select ${fromTable} from ${quote(table.model.sql)} t where ${left} in (${tuples.join(", ")}) and not exists (select 1 from ins where ${match})`;
+  return { text, params: next };
+}
+function uniqueColumns(table, on) {
+  const names = conflictNames(on);
+  for (const unique of table.model.uniques) {
+    if (!same(unique, names))
+      continue;
+    const columns = [];
+    for (const name of names) {
+      const column = table.columns.get(name);
+      if (column === undefined) {
+        fail("OKM1104", `onConflict column ${name} is not on ${table.model.name}.`);
+      }
+      columns.push(column);
+    }
+    return columns;
+  }
+  const accepted = table.model.uniques.map((fields) => fields.join(", "));
+  throwNamed2("OKM1104", names.join(", "), accepted, `onConflict on ${table.model.name} names ${names.join(", ")}, which is not a unique constraint. Accepted: ${list(accepted)}.`);
+}
+function updateColumns(table, value) {
+  if (!Array.isArray(value) || value.length === 0) {
+    fail("OKM1120", "onConflict update must name at least one column.");
+  }
+  const columns = [];
+  for (const name of value) {
+    if (typeof name !== "string")
+      fail("OKM1120", "onConflict update must name columns.");
+    const column = table.columns.get(name);
+    if (column === undefined) {
+      throwNamed2("OKM1120", name, table.names, `Field ${name} is not on ${table.model.name}. Accepted names: ${list(table.names)}.`);
+    }
+    if (!column.writable)
+      refuseWrite(table.model.name, column);
+    columns.push(column);
+  }
+  return columns;
+}
+function conflictNames(on) {
+  if (typeof on === "string")
+    return [on];
+  if (Array.isArray(on) && on.length > 0 && on.every((name) => typeof name === "string")) {
+    return on;
+  }
+  fail("OKM1104", "onConflict on must name a unique constraint's columns.");
+}
+function same(unique, names) {
+  if (unique.length !== names.length)
+    return false;
+  const left = [...unique].sort();
+  const right = [...names].sort();
+  for (let index = 0;index < left.length; index += 1) {
+    if (left[index] !== right[index])
+      return false;
+  }
+  return true;
+}
+function rejectConflictKeys(keys, accepted) {
+  for (const key of keys) {
+    if (!accepted.includes(key)) {
+      throwNamed2("OKM1120", key, accepted, `Option ${key} is not accepted by onConflict. Accepted options: ${list(accepted)}.`);
+    }
+  }
+}
+function refuseWrite(table, column) {
+  if (column.guarded) {
+    fail("OKM1190", `Field ${table}.${column.field} is guarded. Input cannot set it.`);
+  }
+  fail("OKM1120", `Field ${table}.${column.field} cannot be written.`);
+}
+export {
+  finishInsert,
+  readConflict
+};