okmodel 0.1.1 → 0.3.0

package/dist/shared/{ngk8gj61.js → tbszx8mz.js}

@@ -30,6 +30,20 @@ function isConnectionFailure(error) {
   const message = error.message;
   return message.includes("ECONNREFUSED") || message.includes("ECONNRESET") || message.includes("CONNECTION_CLOSED") || message.includes("terminating connection") || message.includes("The pool is closed");
 }
+function isConnectionLost(error) {
+  if (isConnectionFailure(error))
+    return true;
+  if (typeof error !== "object" || error === null)
+    return false;
+  if (Reflect.get(error, "kind") === "outcome_unknown")
+    return true;
+  if (readCode(error, "code") === "ERR_POSTGRES_CONNECTION_CLOSED")
+    return true;
+  if (error instanceof Error && error.message.includes("Connection terminated"))
+    return true;
+  const cause = Reflect.get(error, "cause");
+  return cause !== undefined && cause !== error && isConnectionLost(cause);
+}
 function readCode(error, key) {
   if (typeof error !== "object" || error === null || !(key in error))
     return;
@@ -37,4 +51,4 @@ function readCode(error, key) {
   return typeof value === "string" && value.length > 0 ? value : undefined;
 }
 
-export { isConnectionSqlstate, isConnectionFailure };
+export { isConnectionSqlstate, isConnectionFailure, isConnectionLost };

package/dist/shared/th14ygv2.js

@@ -0,0 +1,69 @@
+import {
+  normaliseEdges,
+  assertProvenance
+} from "./t4tbsy9h.js";
+import {
+  assertIdentifier2
+} from "./nfzc5z0w.js";
+import {
+  catalogError2
+} from "./52szzakm.js";
+
+// src/contracts/catalog/extension.ts
+function extensionObject(input) {
+  assertIdentifier2(input.name, "extension");
+  assertIdentifier2(input.schema, "extension schema");
+  assertProvenance(input.provenance);
+  assertVersion(input.version);
+  const definition = {
+    schema: input.schema,
+    relocatable: input.relocatable ?? true,
+    ...input.version !== undefined ? { version: input.version } : {}
+  };
+  return {
+    kind: "extension",
+    identity: { kind: "extension", name: input.name },
+    owner: input.owner ?? "managed",
+    definition,
+    dependencies: normaliseEdges(input.dependencies ?? []),
+    provenance: input.provenance
+  };
+}
+function isExactVersion(version) {
+  return version !== undefined && /^\d+(?:\.\d+)*$/.test(version);
+}
+function compareExtensionVersions(left, right) {
+  const a = parts(left);
+  const b = parts(right);
+  const length = Math.max(a.length, b.length);
+  for (let index = 0;index < length; index += 1) {
+    const diff = (a[index] ?? 0) - (b[index] ?? 0);
+    if (diff !== 0)
+      return diff < 0 ? -1 : 1;
+  }
+  return 0;
+}
+function sameExtensionDefinition(before, after) {
+  if (before.definition.schema !== after.definition.schema)
+    return false;
+  if (before.definition.relocatable !== after.definition.relocatable)
+    return false;
+  return sameVersion(before.definition.version, after.definition.version);
+}
+function sameVersion(before, after) {
+  if (!isExactVersion(after) || !isExactVersion(before))
+    return true;
+  return before === after;
+}
+function assertVersion(version) {
+  if (version === undefined)
+    return;
+  if (isExactVersion(version) || /^>=\d+(?:\.\d+)*$/.test(version))
+    return;
+  catalogError2("OKM1020", `Extension version ${String(version)} must be a dotted version or a >= floor.`);
+}
+function parts(version) {
+  return version.split(".").map((part) => Number(part));
+}
+
+export { extensionObject, isExactVersion, compareExtensionVersions, sameExtensionDefinition };

package/dist/shared/tmbdywx0.js

@@ -0,0 +1,178 @@
+import {
+  arrayElement
+} from "./94ez8kzh.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/dialects/pg/misuse.ts
+var COLUMN_DEFINITION_CODE = "OKM1060";
+var RESERVED_OPTION_CODE = "OKM1061";
+var CODEC_VALUE_CODE = "OKM1210";
+function definition(message) {
+  throw new OkmError2(COLUMN_DEFINITION_CODE, message);
+}
+function unavailable(message) {
+  throw new OkmError2(RESERVED_OPTION_CODE, message);
+}
+function rejected(message) {
+  throw new OkmError2(CODEC_VALUE_CODE, message);
+}
+
+// src/dialects/pg/array-literal.ts
+function writeArray(value, dims, encode, raw) {
+  return writeLevel(value, dims, encode, raw);
+}
+function readArray(wire, dims, decode) {
+  const cursor = { text: wire, index: 0 };
+  const parsed = parseValue(cursor);
+  skipSpace(cursor);
+  if (cursor.index !== cursor.text.length) {
+    rejected("Array literal has trailing text.");
+  }
+  if (!Array.isArray(parsed)) {
+    rejected("Array literal must start with `{`.");
+  }
+  return interpret(parsed, dims, decode);
+}
+function writeLevel(value, dims, encode, raw) {
+  if (!Array.isArray(value)) {
+    rejected("Array column expected an array.");
+  }
+  const parts = [];
+  if (dims === 1) {
+    for (const item of value) {
+      if (item === null || item === undefined) {
+        rejected("Array elements cannot be null.");
+      }
+      parts.push(arrayElement(encode(item), raw));
+    }
+  } else {
+    for (const item of value) {
+      parts.push(writeLevel(item, dims - 1, encode, raw));
+    }
+  }
+  return `{${parts.join(",")}}`;
+}
+function interpret(nodes, dims, decode) {
+  if (dims === 1) {
+    return nodes.map((cell) => {
+      if (typeof cell !== "string") {
+        rejected("Array rank does not match dims.");
+      }
+      return decode(cell);
+    });
+  }
+  return nodes.map((cell) => {
+    if (!Array.isArray(cell)) {
+      rejected("Array rank does not match dims.");
+    }
+    return interpret(cell, dims - 1, decode);
+  });
+}
+function parseValue(cursor) {
+  skipSpace(cursor);
+  if (peek(cursor) === "{") {
+    return parseArray(cursor);
+  }
+  return parseElement(cursor);
+}
+function parseArray(cursor) {
+  expectChar(cursor, "{");
+  skipSpace(cursor);
+  if (peek(cursor) === "}") {
+    cursor.index += 1;
+    return [];
+  }
+  const items = [];
+  for (;; ) {
+    items.push(parseValue(cursor));
+    skipSpace(cursor);
+    if (peek(cursor) === ",") {
+      cursor.index += 1;
+      skipSpace(cursor);
+      continue;
+    }
+    expectChar(cursor, "}");
+    return items;
+  }
+}
+function parseElement(cursor) {
+  if (peek(cursor) === '"') {
+    return parseQuoted(cursor);
+  }
+  const start = cursor.index;
+  while (cursor.index < cursor.text.length) {
+    const char = cursor.text[cursor.index];
+    if (char === "," || char === "}" || char === undefined || isSpace(char)) {
+      break;
+    }
+    cursor.index += 1;
+  }
+  const token = cursor.text.slice(start, cursor.index);
+  if (token.length === 0) {
+    rejected("Array literal is missing an element.");
+  }
+  if (token === "NULL") {
+    return null;
+  }
+  return token;
+}
+function parseQuoted(cursor) {
+  expectChar(cursor, '"');
+  let out = "";
+  for (;; ) {
+    const char = next(cursor);
+    if (char === undefined) {
+      rejected("Array literal ended inside a quote.");
+    }
+    if (char === '"') {
+      if (peek(cursor) === '"') {
+        cursor.index += 1;
+        out += '"';
+        continue;
+      }
+      return out;
+    }
+    if (char === "\\") {
+      const escaped = next(cursor);
+      if (escaped === undefined) {
+        rejected("Array literal ended inside an escape.");
+      }
+      out += escaped;
+      continue;
+    }
+    out += char;
+  }
+}
+function expectChar(cursor, expected) {
+  if (peek(cursor) !== expected) {
+    rejected(`Array literal expected ${expected}.`);
+  }
+  cursor.index += 1;
+}
+function peek(cursor) {
+  return cursor.text[cursor.index];
+}
+function next(cursor) {
+  const char = cursor.text[cursor.index];
+  if (char !== undefined) {
+    cursor.index += 1;
+  }
+  return char;
+}
+function skipSpace(cursor) {
+  while (cursor.index < cursor.text.length) {
+    const char = cursor.text[cursor.index];
+    if (char === undefined || !isSpace(char)) {
+      return;
+    }
+    cursor.index += 1;
+  }
+}
+function isSpace(char) {
+  return char === " " || char === `
+` || char === "\t";
+}
+
+export { definition, unavailable, rejected, writeArray, readArray };

package/dist/shared/ty3v3hfk.js

@@ -0,0 +1,64 @@
+import {
+  withHttp,
+  attachHttp
+} from "./k34e0xf2.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/runtime/server-check.ts
+var versionQuery = "select current_setting('server_version_num'), version(), (select (xpath('//catalog_hash/text()', query_to_xml('select catalog_hash from okm_meta where id = ''head''', true, false, '')))[1]::text where to_regclass('okm_meta') is not null)";
+async function acceptServer(pool, schema, rows, http, requireMeta, options, source) {
+  for (const name in schema.model) {
+    if (schema.model[name]?.presets !== undefined) {
+      (await import("./r6nwkxnt.js")).checkSchema(schema);
+      break;
+    }
+  }
+  const version = rows[0]?.[1];
+  if (version === null || version === undefined || !version.startsWith("PostgreSQL")) {
+    throw new OkmError2("OKM1801", "The server is not PostgreSQL. The schema dialect is postgres.", withHttp(http, {
+      fix: { summary: "Open the schema with the Postgres driver that matches it." }
+    }));
+  }
+  const recorded = rows[0]?.[2];
+  if (recorded === null || recorded === undefined || recorded.length === 0) {
+    if (requireMeta) {
+      throw new OkmError2("OKM1520", "okm_meta has no catalog hash.", withHttp(http, {
+        fix: {
+          summary: "Apply migrations so okm_meta records the catalog, or omit requireMeta to adopt this database."
+        }
+      }));
+    }
+  } else {
+    const { assertCompatible } = await import("./fptpmvxp.js");
+    try {
+      await assertCompatible(pool, schema, recorded, source, options);
+    } catch (error) {
+      if (error instanceof OkmError2)
+        throw attachHttp(http, error);
+      throw error;
+    }
+  }
+  const major = Math.floor(Number(rows[0]?.[0] ?? "0") / 1e4);
+  const requires = schema.requires?.postgres;
+  if (requires === undefined) {
+    if (major < 15) {
+      throw new OkmError2("OKM1803", `The server is PostgreSQL ${String(major)}. PostgreSQL 15 is the oldest supported.`, withHttp(http, {
+        fix: { summary: "Upgrade to PostgreSQL 15, or set schema({ requires }) to this major." }
+      }));
+    }
+    return;
+  }
+  const match = /^>=(\d+)$/.exec(requires.trim());
+  const need = match?.[1] === undefined ? undefined : Number(match[1]);
+  if (need === undefined || major < need) {
+    throw new OkmError2("OKM1802", `The server is PostgreSQL ${String(major)}. schema({ requires }) asks for ${requires}.`, withHttp(http, {
+      fix: { summary: "Upgrade the server, or lower requires to a version the server meets." }
+    }));
+  }
+}
+export {
+  acceptServer,
+  versionQuery
+};

package/dist/shared/wekze34d.js

@@ -0,0 +1,246 @@
+import {
+  isDomain
+} from "./qbxzvwwc.js";
+import {
+  quoteLiteral
+} from "./94ez8kzh.js";
+import {
+  identityKey2
+} from "./t4tbsy9h.js";
+import {
+  fitIdentifier2
+} from "./nfzc5z0w.js";
+
+// src/dialects/pg/ddl.ts
+function quoteIdent(name) {
+  return `"${name.replaceAll('"', '""')}"`;
+}
+function ownedByView(object) {
+  if (object.kind !== "index")
+    return false;
+  return object.dependencies.some((edge) => edge.target.kind === "view" || edge.target.kind === "materializedView");
+}
+function dropObjectSql(object, schema) {
+  if (object.owner === "ignored")
+    return;
+  switch (object.kind) {
+    case "table":
+      return `drop table ${qualify(schema, object.identity.name)}`;
+    case "column":
+      return `alter table ${qualify(schema, object.identity.parent.name)} drop column ${quoteIdent(object.identity.name)}`;
+    case "index":
+      return `drop index ${qualify(schema, object.identity.name)}`;
+    case "constraint":
+      return `alter table ${qualify(schema, object.identity.parent.name)} drop constraint ${quoteIdent(object.identity.name)}`;
+    case "sequence":
+      return `drop sequence ${qualify(schema, object.identity.name)}`;
+    case "type":
+      return `drop type ${qualify(schema, object.identity.name)}`;
+    case "extension":
+      return `drop extension ${quoteIdent(object.identity.name)}`;
+    case "function":
+      return `drop function ${qualify(schema, object.identity.name)}(${object.identity.argTypes.join(", ")})`;
+    case "trigger":
+      return `drop trigger ${quoteIdent(object.identity.name)} on ${qualify(schema, object.identity.parent.name)}`;
+    case "view":
+      return `drop view ${qualify(schema, object.identity.name)}`;
+    case "materializedView":
+      return `drop materialized view ${qualify(schema, object.identity.name)}`;
+    default:
+      return;
+  }
+}
+function createObjectSql(object, schema) {
+  switch (object.kind) {
+    case "column":
+      return `alter table ${qualify(schema, object.identity.parent.name)} add column ${columnSql(object)}`;
+    case "index":
+      return createIndexSql(object, schema);
+    case "constraint":
+      return `alter table ${qualify(schema, object.identity.parent.name)} add constraint ${quoteIdent(object.identity.name)} ${constraintBody(object, schema)}`;
+    case "sequence":
+      return createSequenceSql(object, schema);
+    case "type":
+      return createTypeSql(object, schema);
+    case "extension":
+      return createExtensionSql(object);
+    case "function":
+      return functionSql(object, schema, false);
+    case "trigger":
+      return triggerSql(object, schema);
+    case "view":
+      return viewSql(object, schema, false);
+    case "materializedView":
+      return materializedViewSql(object, schema);
+    case "table":
+      return;
+    default:
+      return;
+  }
+}
+function functionSql(object, schema, replace) {
+  const definition = object.definition;
+  const args = definition.arguments.map((argument) => `${quoteIdent(argument.name)} ${argument.type}`).join(", ");
+  const head = `${replace ? "create or replace" : "create"} function ${qualify(schema, object.identity.name)}(${args})`;
+  const security = ` security ${definition.security}`;
+  const path = definition.searchPath === undefined ? "" : ` set search_path to ${definition.searchPath}`;
+  const tail = `returns ${definition.returns} language ${definition.language} ${definition.volatility}${security}${path}`;
+  if (definition.atomic)
+    return `${head} ${tail} ${definition.body}`;
+  return `${head} ${tail} as ${dollarQuote(definition.body)}`;
+}
+function viewSql(object, schema, replace) {
+  const verb = replace ? "create or replace view" : "create view";
+  return `${verb} ${qualify(schema, object.identity.name)} as ${object.definition.query}`;
+}
+function materializedViewSql(object, schema) {
+  return `create materialized view ${qualify(schema, object.identity.name)} as ${object.definition.query} with no data`;
+}
+function refreshMaterializedViewSql(object, schema, populated = false) {
+  const concurrently = populated && object.definition.refresh === "concurrently" ? " concurrently" : "";
+  return `refresh materialized view${concurrently} ${qualify(schema, object.identity.name)}`;
+}
+function triggerSql(object, schema) {
+  const definition = object.definition;
+  const timing = definition.timing === "instead" ? "instead of" : definition.timing;
+  const events = definition.events.map((event) => {
+    if (event !== "update" || definition.updateOf === undefined)
+      return event;
+    return `update of ${definition.updateOf.map((column) => quoteIdent(column)).join(", ")}`;
+  }).join(" or ");
+  const when = definition.when === undefined ? "" : ` when (${definition.when})`;
+  const args = definition.calls.argTypes.join(", ");
+  const fn = `${qualify(schema, definition.calls.name)}(${args})`;
+  return `create trigger ${quoteIdent(object.identity.name)} ${timing} ${events} on ${qualify(schema, object.identity.parent.name)} for each ${definition.level}${when} execute function ${fn}`;
+}
+function dollarQuote(body) {
+  let tag = "okm";
+  while (body.includes(`$${tag}$`))
+    tag = `${tag}_`;
+  return `$${tag}$${body}$${tag}$`;
+}
+function alterColumnSql(before, after, schema) {
+  const statements = [];
+  const table = qualify(schema, after.identity.parent.name);
+  const name = quoteIdent(after.identity.name);
+  const typeChanged = before.definition.dataType !== after.definition.dataType;
+  const collationChanged = before.definition.collation !== after.definition.collation;
+  if (typeChanged || collationChanged) {
+    const using = typeChanged ? ` using ${name}::${after.definition.dataType}` : "";
+    statements.push(`alter table ${table} alter column ${name} set data type ${after.definition.dataType}${collateSql(after.definition.collation)}${using}`);
+  }
+  if (before.definition.nullable !== after.definition.nullable) {
+    statements.push(`alter table ${table} alter column ${name} ${after.definition.nullable ? "drop not null" : "set not null"}`);
+  }
+  if (before.definition.defaultExpression !== after.definition.defaultExpression) {
+    statements.push(after.definition.defaultExpression === undefined ? `alter table ${table} alter column ${name} drop default` : `alter table ${table} alter column ${name} set default ${after.definition.defaultExpression}`);
+  }
+  return statements;
+}
+function identitySequence(sequence, source) {
+  const key = identityKey2(sequence.identity);
+  return source.objects.some((object) => {
+    if (object.kind !== "column" || object.definition.identity === undefined)
+      return false;
+    return object.dependencies.some((edge) => identityKey2(edge.target) === key);
+  });
+}
+function createTableSql(tableObject, source, schema) {
+  const parent = tableObject.identity.name;
+  const columns = source.objects.filter((object) => object.kind === "column" && object.identity.parent.name === parent);
+  const primary = source.objects.find((object) => object.kind === "constraint" && object.definition.constraintKind === "primaryKey" && object.identity.parent.name === parent);
+  const lines = columns.map((column) => columnSql(column));
+  if (primary !== undefined) {
+    const cols = primary.definition.columns.map((name) => quoteIdent(name)).join(", ");
+    lines.push(`constraint ${quoteIdent(primary.identity.name)} primary key (${cols})`);
+  }
+  const partition = tableObject.definition.partition;
+  const tail = partition === undefined ? "" : ` partition by ${partition.method} (${partition.columns.map((name) => quoteIdent(name)).join(", ")})`;
+  return `create table ${qualify(schema, parent)} (
+  ${lines.join(`,
+  `)}
+)${tail}`;
+}
+function collateSql(collation) {
+  if (collation === undefined)
+    return "";
+  return ` collate ${quoteIdent(collation)}`;
+}
+function createTypeSql(object, schema) {
+  if (isDomain(object.definition)) {
+    const name = object.identity.name;
+    const constraint = quoteIdent(fitIdentifier2(`${name}_check`));
+    return `create domain ${qualify(schema, name)} as ${object.definition.base} constraint ${constraint} check (${object.definition.check})`;
+  }
+  const labels = object.definition.labels.map((label) => quoteLiteral(label)).join(", ");
+  return `create type ${qualify(schema, object.identity.name)} as enum (${labels})`;
+}
+function columnSql(column) {
+  const definition = column.definition;
+  let sql = `${quoteIdent(column.identity.name)} ${definition.dataType}${collateSql(definition.collation)}`;
+  if (definition.identity !== undefined) {
+    sql += definition.identity.always ? " generated always as identity" : " generated by default as identity";
+  } else if (definition.generated !== undefined) {
+    sql += ` generated always as (${definition.generated.expression}) stored`;
+  }
+  if (!definition.nullable)
+    sql += " not null";
+  if (definition.defaultExpression !== undefined)
+    sql += ` default ${definition.defaultExpression}`;
+  return sql;
+}
+function createIndexSql(object, schema) {
+  const unique = object.definition.unique ? "unique " : "";
+  const where = object.definition.predicate === undefined ? "" : ` where ${object.definition.predicate}`;
+  const expression = object.definition.expression;
+  const name = quoteIdent(object.identity.name);
+  const on = qualify(schema, object.identity.parent.name);
+  if (expression !== undefined && expression.startsWith("using ")) {
+    return `create ${unique}index ${name} on ${on} ${expression}${where}`;
+  }
+  const target = expression !== undefined ? `(${expression})` : object.definition.columns.map((column) => quoteIdent(column)).join(", ");
+  return `create ${unique}index ${name} on ${on} (${target})${where}`;
+}
+function createExtensionSql(object) {
+  const version = object.definition.version;
+  const pinned = version !== undefined && /^\d+(?:\.\d+)*$/.test(version) ? ` version ${quoteLiteral(version)}` : "";
+  return `create extension ${quoteIdent(object.identity.name)} schema ${quoteIdent(object.definition.schema)}${pinned}`;
+}
+function createSequenceSql(object, schema) {
+  const definition = object.definition;
+  const cycle = definition.cycle ? " cycle" : "";
+  return `create sequence ${qualify(schema, object.identity.name)} as ${definition.dataType} start ${definition.start} increment ${definition.increment}${cycle}`;
+}
+function constraintBody(object, schema) {
+  const definition = object.definition;
+  const columns = definition.columns.map((name) => quoteIdent(name)).join(", ");
+  switch (definition.constraintKind) {
+    case "primaryKey":
+      return `primary key (${columns})`;
+    case "unique": {
+      const nulls = definition.nullsNotDistinct ? " nulls not distinct" : "";
+      return `unique${nulls} (${columns})${deferClause(definition)}`;
+    }
+    case "check":
+      return `check (${definition.expression ?? "true"})${deferClause(definition)}`;
+    case "foreignKey": {
+      const references = definition.references;
+      const target = references === undefined ? "" : ` references ${qualify(schema, references.parent.name)} (${references.columns.map((name) => quoteIdent(name)).join(", ")})`;
+      const onDelete = references?.onDelete === undefined ? "" : ` on delete ${references.onDelete}`;
+      const onUpdate = references?.onUpdate === undefined ? "" : ` on update ${references.onUpdate}`;
+      return `foreign key (${columns})${target}${onDelete}${onUpdate}${deferClause(definition)}`;
+    }
+    default:
+      return definition.constraintKind;
+  }
+}
+function deferClause(definition) {
+  if (!definition.deferrable)
+    return "";
+  return ` deferrable initially ${definition.initially}`;
+}
+function qualify(schema, name) {
+  return `${quoteIdent(schema)}.${quoteIdent(name)}`;
+}
+
+export { quoteIdent, ownedByView, dropObjectSql, createObjectSql, functionSql, viewSql, refreshMaterializedViewSql, alterColumnSql, identitySequence, createTableSql, qualify };