okmodel 0.0.0 → 0.1.0

package/dist/shared/mkjmqjv4.js

@@ -0,0 +1,456 @@
+import {
+  catalogError2
+} from "./ycwz42az.js";
+
+// src/contracts/utf8.ts
+function utf8ByteLength2(value) {
+  const length = value.length;
+  for (let index = 0;index < length; index += 1) {
+    if (value.charCodeAt(index) > 127) {
+      return utf8ByteLengthFull(value);
+    }
+  }
+  return length;
+}
+function utf8ByteLengthFull(value) {
+  let bytes = 0;
+  for (let index = 0;index < value.length; ) {
+    const unit = readCode(value, index);
+    bytes += utf8Width(unit.code);
+    index += unit.units;
+  }
+  return bytes;
+}
+function encodeUtf8(value) {
+  const bytes = new Uint8Array(value.length);
+  for (let index = 0;index < value.length; index++) {
+    const code = value.charCodeAt(index);
+    if (code > 127) {
+      return encodeUtf8Slow(value);
+    }
+    bytes[index] = code;
+  }
+  return bytes;
+}
+function truncateUtf8(value, budget) {
+  if (budget <= 0) {
+    return "";
+  }
+  let bytes = 0;
+  let end = 0;
+  for (let index = 0;index < value.length; ) {
+    const unit = readCode(value, index);
+    const width = utf8Width(unit.code);
+    if (bytes + width > budget) {
+      break;
+    }
+    bytes += width;
+    index += unit.units;
+    end = index;
+  }
+  return value.slice(0, end);
+}
+function encodeUtf8Slow(value) {
+  const bytes = new Uint8Array(utf8ByteLength2(value));
+  let offset = 0;
+  for (let index = 0;index < value.length; ) {
+    const unit = readCode(value, index);
+    offset = writeUtf8(bytes, offset, unit.code);
+    index += unit.units;
+  }
+  return bytes;
+}
+function readCode(value, index) {
+  const lead = value.charCodeAt(index);
+  const next = value.charCodeAt(index + 1);
+  if (lead >= 55296 && lead <= 56319 && next >= 56320 && next <= 57343) {
+    return {
+      code: 65536 + (lead - 55296 << 10) + (next - 56320),
+      units: 2
+    };
+  }
+  return { code: lead, units: 1 };
+}
+function utf8Width(code) {
+  if (code <= 127) {
+    return 1;
+  }
+  if (code <= 2047) {
+    return 2;
+  }
+  if (code <= 65535) {
+    return 3;
+  }
+  return 4;
+}
+function writeUtf8(bytes, offset, code) {
+  if (code <= 127) {
+    bytes[offset] = code;
+    return offset + 1;
+  }
+  if (code <= 2047) {
+    bytes[offset] = 192 | code >> 6;
+    bytes[offset + 1] = 128 | code & 63;
+    return offset + 2;
+  }
+  if (code <= 65535) {
+    bytes[offset] = 224 | code >> 12;
+    bytes[offset + 1] = 128 | code >> 6 & 63;
+    bytes[offset + 2] = 128 | code & 63;
+    return offset + 3;
+  }
+  bytes[offset] = 240 | code >> 18;
+  bytes[offset + 1] = 128 | code >> 12 & 63;
+  bytes[offset + 2] = 128 | code >> 6 & 63;
+  bytes[offset + 3] = 128 | code & 63;
+  return offset + 4;
+}
+
+// src/contracts/sha256.ts
+var HEX = "0123456789abcdef";
+var constants;
+function sha2562(text) {
+  return toHex(sha256Bytes(encodeUtf8(text)));
+}
+function roundConstants() {
+  constants ??= new Uint32Array([
+    1116352408,
+    1899447441,
+    3049323471,
+    3921009573,
+    961987163,
+    1508970993,
+    2453635748,
+    2870763221,
+    3624381080,
+    310598401,
+    607225278,
+    1426881987,
+    1925078388,
+    2162078206,
+    2614888103,
+    3248222580,
+    3835390401,
+    4022224774,
+    264347078,
+    604807628,
+    770255983,
+    1249150122,
+    1555081692,
+    1996064986,
+    2554220882,
+    2821834349,
+    2952996808,
+    3210313671,
+    3336571891,
+    3584528711,
+    113926993,
+    338241895,
+    666307205,
+    773529912,
+    1294757372,
+    1396182291,
+    1695183700,
+    1986661051,
+    2177026350,
+    2456956037,
+    2730485921,
+    2820302411,
+    3259730800,
+    3345764771,
+    3516065817,
+    3600352804,
+    4094571909,
+    275423344,
+    430227734,
+    506948616,
+    659060556,
+    883997877,
+    958139571,
+    1322822218,
+    1537002063,
+    1747873779,
+    1955562222,
+    2024104815,
+    2227730452,
+    2361852424,
+    2428436474,
+    2756734187,
+    3204031479,
+    3329325298
+  ]);
+  return constants;
+}
+function sha256Bytes(message) {
+  const k = roundConstants();
+  const bitLength = message.length * 8;
+  const pad = (64 - (message.length + 9) % 64) % 64;
+  const total = message.length + 1 + pad + 8;
+  const data = new Uint8Array(total);
+  data.set(message);
+  data[message.length] = 128;
+  const view = new DataView(data.buffer);
+  view.setUint32(total - 8, Math.floor(bitLength / 4294967296));
+  view.setUint32(total - 4, bitLength >>> 0);
+  let h0 = 1779033703;
+  let h1 = 3144134277;
+  let h2 = 1013904242;
+  let h3 = 2773480762;
+  let h4 = 1359893119;
+  let h5 = 2600822924;
+  let h6 = 528734635;
+  let h7 = 1541459225;
+  const w = new Uint32Array(64);
+  for (let offset = 0;offset < data.length; offset += 64) {
+    for (let index = 0;index < 16; index++) {
+      w[index] = view.getUint32(offset + index * 4);
+    }
+    for (let index = 16;index < 64; index++) {
+      const w15 = w[index - 15] ?? 0;
+      const w2 = w[index - 2] ?? 0;
+      const s0 = rotr(w15, 7) ^ rotr(w15, 18) ^ w15 >>> 3;
+      const s1 = rotr(w2, 17) ^ rotr(w2, 19) ^ w2 >>> 10;
+      w[index] = (w[index - 16] ?? 0) + s0 + (w[index - 7] ?? 0) + s1 >>> 0;
+    }
+    let a = h0;
+    let b = h1;
+    let c = h2;
+    let d = h3;
+    let e = h4;
+    let f = h5;
+    let g = h6;
+    let h = h7;
+    for (let index = 0;index < 64; index++) {
+      const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const ch = e & f ^ ~e & g;
+      const temp1 = h + s1 + ch + (k[index] ?? 0) + (w[index] ?? 0) >>> 0;
+      const s0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const temp2 = s0 + maj >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    h0 = h0 + a >>> 0;
+    h1 = h1 + b >>> 0;
+    h2 = h2 + c >>> 0;
+    h3 = h3 + d >>> 0;
+    h4 = h4 + e >>> 0;
+    h5 = h5 + f >>> 0;
+    h6 = h6 + g >>> 0;
+    h7 = h7 + h >>> 0;
+  }
+  const out = new Uint8Array(32);
+  const outView = new DataView(out.buffer);
+  outView.setUint32(0, h0);
+  outView.setUint32(4, h1);
+  outView.setUint32(8, h2);
+  outView.setUint32(12, h3);
+  outView.setUint32(16, h4);
+  outView.setUint32(20, h5);
+  outView.setUint32(24, h6);
+  outView.setUint32(28, h7);
+  return out;
+}
+function rotr(value, bits) {
+  return value >>> bits | value << 32 - bits;
+}
+function toHex(bytes) {
+  let hex = "";
+  for (let index = 0;index < bytes.length; index++) {
+    const byte = bytes[index] ?? 0;
+    hex += HEX[byte >>> 4];
+    hex += HEX[byte & 15];
+  }
+  return hex;
+}
+
+// src/contracts/catalog/words.ts
+var words;
+function reservedWords() {
+  words ??= new Set([
+    "all",
+    "analyse",
+    "analyze",
+    "and",
+    "any",
+    "array",
+    "as",
+    "asc",
+    "asymmetric",
+    "authorization",
+    "binary",
+    "both",
+    "case",
+    "cast",
+    "check",
+    "collate",
+    "collation",
+    "column",
+    "concurrently",
+    "constraint",
+    "create",
+    "cross",
+    "current_catalog",
+    "current_date",
+    "current_role",
+    "current_schema",
+    "current_time",
+    "current_timestamp",
+    "current_user",
+    "default",
+    "deferrable",
+    "desc",
+    "distinct",
+    "do",
+    "else",
+    "end",
+    "except",
+    "false",
+    "fetch",
+    "for",
+    "foreign",
+    "freeze",
+    "from",
+    "full",
+    "grant",
+    "group",
+    "having",
+    "ilike",
+    "in",
+    "initially",
+    "inner",
+    "intersect",
+    "into",
+    "is",
+    "isnull",
+    "join",
+    "lateral",
+    "leading",
+    "left",
+    "like",
+    "limit",
+    "localtime",
+    "localtimestamp",
+    "natural",
+    "not",
+    "notnull",
+    "null",
+    "offset",
+    "on",
+    "only",
+    "or",
+    "order",
+    "outer",
+    "overlaps",
+    "placing",
+    "primary",
+    "references",
+    "returning",
+    "right",
+    "select",
+    "session_user",
+    "similar",
+    "some",
+    "symmetric",
+    "system_user",
+    "table",
+    "tablesample",
+    "then",
+    "to",
+    "trailing",
+    "true",
+    "union",
+    "unique",
+    "user",
+    "using",
+    "variadic",
+    "verbose",
+    "when",
+    "where",
+    "window",
+    "with"
+  ]);
+  return words;
+}
+
+// src/contracts/catalog/identifier.ts
+var POSTGRES_IDENTIFIER_MAX_BYTES2 = 63;
+var SUFFIX_HEX = 8;
+var SUFFIX_BYTES = SUFFIX_HEX + 1;
+var NAME_TAG = {
+  unique: "key",
+  foreignKey: "fkey",
+  check: "check",
+  index: "idx"
+};
+function isReservedIdentifier2(name) {
+  return reservedWords().has(name.toLowerCase());
+}
+function assertIdentifier2(name, role, limit = POSTGRES_IDENTIFIER_MAX_BYTES2) {
+  assertLimit(limit);
+  assertIdentifierText(name, role);
+  if (utf8ByteLength2(name) > limit) {
+    catalogError2("OKM1122", `${role} ${name} is ${String(utf8ByteLength2(name))} bytes. The limit is ${String(limit)}.`);
+  }
+  if (isReservedIdentifier2(name)) {
+    catalogError2("OKM1122", `${role} ${name} is a reserved word.`);
+  }
+}
+function fitIdentifier2(name, limit = POSTGRES_IDENTIFIER_MAX_BYTES2) {
+  assertLimit(limit);
+  assertIdentifierText(name, "identifier");
+  if (utf8ByteLength2(name) <= limit) {
+    return name;
+  }
+  const suffix = `_${sha2562(name).slice(0, SUFFIX_HEX)}`;
+  const budget = limit - SUFFIX_BYTES;
+  return `${truncateUtf8(name, budget)}${suffix}`;
+}
+function deterministicName2(input) {
+  const limit = input.limit ?? POSTGRES_IDENTIFIER_MAX_BYTES2;
+  assertIdentifier2(input.parent, "parent", limit);
+  if (input.purpose === "primaryKey") {
+    return fitIdentifier2(`${input.parent}_pkey`, limit);
+  }
+  const nameKey = input.nameKey ?? "";
+  assertIdentifierText(nameKey, "name key");
+  return fitIdentifier2(`${input.parent}_${nameKey}_${NAME_TAG[input.purpose]}`, limit);
+}
+function assertStoredText(value, role) {
+  if (value.includes("\x00") || hasControl(value)) {
+    catalogError2("OKM1122", `${role} contains a control character.`);
+  }
+}
+function assertIdentifierText(name, role) {
+  if (name.length === 0) {
+    catalogError2("OKM1122", `${role} is empty.`);
+  }
+  if (name.includes("\x00")) {
+    catalogError2("OKM1122", `${role} ${name} contains NUL.`);
+  }
+  if (hasControl(name)) {
+    catalogError2("OKM1122", `${role} ${name} contains a control character.`);
+  }
+}
+function assertLimit(limit) {
+  if (!Number.isSafeInteger(limit) || limit < SUFFIX_BYTES) {
+    catalogError2("OKM1122", `Identifier limit is ${String(limit)} bytes. It must be at least ${String(SUFFIX_BYTES)} so a fitted name can keep its hash suffix.`);
+  }
+}
+function hasControl(value) {
+  for (let index = 0;index < value.length; index++) {
+    const code = value.charCodeAt(index);
+    if (code < 32 || code === 127 || code >= 128 && code <= 159) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export { utf8ByteLength2, sha2562, POSTGRES_IDENTIFIER_MAX_BYTES2, isReservedIdentifier2, assertIdentifier2, fitIdentifier2, deterministicName2, assertStoredText };

package/dist/shared/mtkwv8wx.js

@@ -0,0 +1,18 @@
+import {
+  DriverError2,
+  cancelled2,
+  timedOut2,
+  outcomeUnknown2,
+  acquireTimeout2,
+  errorField2,
+  mapDriverError2
+} from "./hd293j9g.js";
+export {
+  DriverError2 as DriverError,
+  acquireTimeout2 as acquireTimeout,
+  cancelled2 as cancelled,
+  errorField2 as errorField,
+  mapDriverError2 as mapDriverError,
+  outcomeUnknown2 as outcomeUnknown,
+  timedOut2 as timedOut
+};

package/dist/shared/ngk8gj61.js

@@ -0,0 +1,40 @@
+// src/contracts/connection.ts
+function isConnectionSqlstate(sqlstate) {
+  return sqlstate.startsWith("08") || sqlstate === "53300" || sqlstate === "57P01" || sqlstate === "57P02" || sqlstate === "57P03";
+}
+function isConnectionErrno(code) {
+  switch (code) {
+    case "ECONNRESET":
+    case "ECONNREFUSED":
+    case "EPIPE":
+    case "ENOTFOUND":
+    case "ETIMEDOUT":
+    case "EHOSTUNREACH":
+    case "ENETUNREACH":
+    case "EAI_AGAIN":
+    case "CONNECTION_CLOSED":
+    case "CONNECTION_ENDED":
+    case "CONNECTION_DESTROYED":
+      return true;
+    default:
+      return false;
+  }
+}
+function isConnectionFailure(error) {
+  const sqlstate = readCode(error, "sqlstate") ?? readCode(error, "code");
+  if (sqlstate !== undefined && (isConnectionSqlstate(sqlstate) || isConnectionErrno(sqlstate))) {
+    return true;
+  }
+  if (!(error instanceof Error))
+    return false;
+  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 readCode(error, key) {
+  if (typeof error !== "object" || error === null || !(key in error))
+    return;
+  const value = Reflect.get(error, key);
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+export { isConnectionSqlstate, isConnectionFailure };

package/dist/shared/p0cbr3g2.js

@@ -0,0 +1,79 @@
+import {
+  OkmError2
+} from "./ycwz42az.js";
+
+// src/runtime/drift-detail.ts
+function driftVerdict(codeHash, recordedHash, migrations) {
+  const codeAt = indexOfHash(migrations, codeHash);
+  const recordedAt = indexOfHash(migrations, recordedHash);
+  if (codeAt < 0 || recordedAt < 0 || recordedAt < codeAt)
+    return "behind";
+  if (recordedAt === codeAt)
+    return "ok";
+  for (let index = codeAt + 1;index <= recordedAt; index += 1) {
+    if (migrations[index]?.expand !== true)
+      return "contract";
+  }
+  return "ok";
+}
+async function assertDrift(pool, codeHash, recordedHash, options) {
+  let rows;
+  try {
+    const result = await pool.execute("select migration_id, class, catalog_hash from okm_history order by migration_id, step_index", undefined, options);
+    rows = result.rows;
+  } catch (error) {
+    throw behind(error);
+  }
+  const verdict = driftVerdict(codeHash, recordedHash, groupMigrations(rows));
+  if (verdict === "ok")
+    return;
+  if (verdict === "contract") {
+    throw new OkmError2("OKM1520", "The database is ahead of the code by a contract migration.", {
+      fix: {
+        summary: "Roll the application forward, or repair the database. A contract step is not compatible with this code."
+      }
+    });
+  }
+  throw behind(undefined);
+}
+function indexOfHash(migrations, hash) {
+  let found = -1;
+  for (let index = 0;index < migrations.length; index += 1) {
+    if (migrations[index]?.catalogHash === hash)
+      found = index;
+  }
+  return found;
+}
+function groupMigrations(rows) {
+  const grouped = [];
+  for (const row of rows) {
+    const id = row[0];
+    const stepClass = row[1];
+    const hash = row[2];
+    if (id == null || stepClass == null || hash == null)
+      continue;
+    const expand = stepClass === "expand";
+    const last = grouped.at(-1);
+    if (last !== undefined && last.id === id) {
+      grouped[grouped.length - 1] = {
+        id,
+        catalogHash: hash,
+        expand: last.expand && expand
+      };
+      continue;
+    }
+    grouped.push({ id, catalogHash: hash, expand });
+  }
+  return grouped;
+}
+function behind(cause) {
+  return new OkmError2("OKM1520", "The database is behind the code.", {
+    ...cause === undefined ? {} : { cause },
+    fix: {
+      summary: "Inspect the diff and repair the database, or generate a migration that matches the drift."
+    }
+  });
+}
+export {
+  assertDrift
+};