okmodel 0.0.0 → 0.1.1

package/dist/shared/fgqgsb5z.js

@@ -0,0 +1,281 @@
+import {
+  PGLITE_CAPABILITIES,
+  driverErrors,
+  rejectClosed,
+  rejectCancelled,
+  rejectTimedOut,
+  mapFailure,
+  nextTransactionDepth,
+  runCall,
+  EMPTY_NOTICES,
+  resultFrom
+} from "./xy79j5hq.js";
+
+// src/adapters/pg/pglite.ts
+import { PGlite } from "@electric-sql/pglite";
+var RESET_ALL = "RESET ALL";
+var UNLOCK = "SELECT pg_advisory_unlock_all()";
+async function open3(config = {}) {
+  const db = new PGlite({
+    dataDir: config.dataDir ?? "memory://",
+    parsers: WIRE,
+    serializers: WIRE
+  });
+  await db.waitReady;
+  const acquireMs = config.timeouts?.acquire;
+  const slot = new Slot;
+  const notices = noticeBuffer();
+  const queryOptions = {
+    rowMode: "array",
+    parsers: WIRE,
+    serializers: WIRE,
+    onNotice(notice) {
+      notices.push(notice);
+    }
+  };
+  let closed = false;
+  let inflight = 0;
+  const session = new PgliteSession(db, queryOptions, notices, () => {
+    inflight += 1;
+  }, () => {
+    inflight = Math.max(0, inflight - 1);
+  });
+  async function lease() {
+    if (closed)
+      return rejectClosed();
+    await slot.acquire(acquireMs);
+    let released = false;
+    return {
+      execute: (text, params, options) => runCall(closed, options, (watch) => session.query(text, params, watch)),
+      batch: (statements, options) => runCall(closed, options, async (watch) => {
+        const { runAtomicBatch } = await import("./dynq16vb.js");
+        return runAtomicBatch(session, statements, watch);
+      }),
+      async release() {
+        if (released)
+          return;
+        released = true;
+        try {
+          await reset(session);
+        } finally {
+          slot.release();
+        }
+      }
+    };
+  }
+  return {
+    capabilities: PGLITE_CAPABILITIES,
+    execute(text, params, options) {
+      return runCall(closed, options, async (watch) => {
+        await slot.acquire(acquireMs);
+        try {
+          return await session.query(text, params, watch);
+        } finally {
+          slot.release();
+        }
+      });
+    },
+    async batch(statements, options) {
+      const connection = await lease();
+      try {
+        return await connection.batch(statements, options);
+      } finally {
+        await connection.release();
+      }
+    },
+    reserve: () => lease(),
+    async describe(text) {
+      await slot.acquire(acquireMs);
+      try {
+        const described = await db.describeQuery(text);
+        return {
+          columns: described.resultFields.map((field) => field.name),
+          parameterCount: described.queryParams.length
+        };
+      } finally {
+        slot.release();
+      }
+    },
+    async listen(channel, onNotify) {
+      const unlisten = await db.listen(channel, onNotify);
+      return async () => {
+        await unlisten();
+      };
+    },
+    stats() {
+      return { size: 1, idle: slot.idle, inflight, waiting: slot.waiting };
+    },
+    async close() {
+      closed = true;
+      await db.close();
+    }
+  };
+}
+
+class PgliteSession {
+  canCancel = false;
+  transactionDepth = 0;
+  db;
+  options;
+  notices;
+  enter;
+  leave;
+  constructor(db, options, notices, enter, leave) {
+    this.db = db;
+    this.options = options;
+    this.notices = notices;
+    this.enter = enter;
+    this.leave = leave;
+  }
+  query(text, params, watch) {
+    const why = watch?.reason();
+    if (why === "timeout")
+      return rejectTimedOut();
+    if (why === "cancelled" || watch?.signal.aborted === true)
+      return rejectCancelled();
+    this.enter();
+    const pending = params === undefined || params.length === 0 ? this.db.query(text, undefined, this.options) : this.db.query(text, params, this.options);
+    return pending.then((result) => {
+      this.leave();
+      this.note(text);
+      return resultFrom(result, this.notices.take());
+    }, (error) => {
+      this.leave();
+      this.notices.take();
+      return mapFailure(error).then((mapped) => {
+        throw mapped;
+      });
+    });
+  }
+  inTransaction() {
+    return this.transactionDepth > 0;
+  }
+  abandon() {
+    this.transactionDepth = 0;
+  }
+  rollback() {
+    return this.query("ROLLBACK", undefined, undefined).then(() => {
+      this.transactionDepth = 0;
+    }, (error) => {
+      this.transactionDepth = 0;
+      throw error;
+    });
+  }
+  note(text) {
+    this.transactionDepth = nextTransactionDepth(this.transactionDepth, text);
+  }
+}
+function noticeBuffer() {
+  let notices;
+  return {
+    push(notice) {
+      const severity = notice.severity ?? "";
+      const message = notice.message ?? "";
+      const code = notice.code !== undefined && notice.code.length > 0 ? notice.code : undefined;
+      const entry = code === undefined ? { severity, message } : { severity, message, code };
+      (notices ??= []).push(entry);
+    },
+    take() {
+      const taken = notices ?? EMPTY_NOTICES;
+      notices = undefined;
+      return taken;
+    }
+  };
+}
+
+class Slot {
+  held = false;
+  waiters = [];
+  acquire(acquireMs) {
+    if (!this.held) {
+      this.held = true;
+      return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+      const waiter = {
+        resolve,
+        timer: undefined
+      };
+      if (acquireMs !== undefined) {
+        waiter.timer = setTimeout(() => {
+          const index = this.waiters.indexOf(waiter);
+          if (index !== -1)
+            this.waiters.splice(index, 1);
+          driverErrors().then((errors) => {
+            reject(errors.acquireTimeout());
+          });
+        }, acquireMs);
+      }
+      this.waiters.push(waiter);
+    });
+  }
+  release() {
+    const next = this.waiters.shift();
+    if (next === undefined) {
+      this.held = false;
+      return;
+    }
+    if (next.timer !== undefined)
+      clearTimeout(next.timer);
+    next.resolve();
+  }
+  get idle() {
+    return this.held ? 0 : 1;
+  }
+  get waiting() {
+    return this.waiters.length;
+  }
+}
+async function reset(session) {
+  if (session.inTransaction())
+    await session.rollback().catch(() => {
+      return;
+    });
+  try {
+    await session.query(RESET_ALL, undefined, undefined);
+    await session.query(UNLOCK, undefined, undefined);
+  } catch {
+    await session.rollback().catch(() => {
+      return;
+    });
+    await session.query(RESET_ALL, undefined, undefined);
+    await session.query(UNLOCK, undefined, undefined);
+  }
+}
+function wireMap(oids) {
+  const parsers = {};
+  for (const oid of oids)
+    parsers[oid] = (value) => value;
+  return parsers;
+}
+var WIRE = wireMap([
+  16,
+  17,
+  20,
+  21,
+  23,
+  25,
+  114,
+  700,
+  701,
+  1043,
+  1082,
+  1114,
+  1184,
+  1700,
+  2950,
+  3802,
+  1000,
+  1005,
+  1007,
+  1009,
+  1016,
+  1115,
+  1182,
+  1185,
+  1231,
+  199,
+  3807
+]);
+
+export { open3 };

package/dist/shared/g5fhqmwe.js

@@ -0,0 +1,188 @@
+import {
+  CATALOG_VERSION2,
+  assertNamespace2,
+  identityKey2,
+  identityLabel2,
+  normaliseEdges,
+  compareText,
+  assertProvenance
+} from "./j5cn2963.js";
+import {
+  assertIdentifier2,
+  assertStoredText
+} from "./mkjmqjv4.js";
+import {
+  catalogError2
+} from "./ycwz42az.js";
+
+// src/contracts/catalog/order.ts
+function indexObjects(objects) {
+  const seen = new Set;
+  const indexed = [];
+  for (const object of objects) {
+    const key = identityKey2(object.identity);
+    if (seen.has(key)) {
+      catalogError2("OKM1023", `Duplicate identity for ${identityLabel2(object.identity)}.`);
+    }
+    seen.add(key);
+    indexed.push({ key, object });
+  }
+  return indexed;
+}
+function dependencyOrder(objects) {
+  return orderIndexed(indexObjects(objects));
+}
+function orderIndexed(indexed) {
+  const byKey = new Map;
+  for (const item of indexed) {
+    byKey.set(item.key, item.object);
+  }
+  const dependents = new Map;
+  const remaining = new Map;
+  for (const item of indexed) {
+    dependents.set(item.key, []);
+    remaining.set(item.key, 0);
+  }
+  for (const item of indexed) {
+    const seen = new Set;
+    for (const edge of item.object.dependencies) {
+      const dependency = identityKey2(edge.target);
+      if (dependency === item.key) {
+        catalogError2("OKM1020", `${identityLabel2(item.object.identity)} depends on itself.`);
+      }
+      if (!byKey.has(dependency)) {
+        catalogError2("OKM1020", `${identityLabel2(item.object.identity)} depends on ${identityLabel2(edge.target)}, which is not in the catalog.`);
+      }
+      if (seen.has(dependency)) {
+        continue;
+      }
+      seen.add(dependency);
+      remaining.set(item.key, (remaining.get(item.key) ?? 0) + 1);
+      dependents.get(dependency)?.push(item.key);
+    }
+  }
+  const ready = indexed.filter((item) => remaining.get(item.key) === 0).map((item) => item.key);
+  ready.sort(compareText);
+  const ordered = [];
+  let cursor = 0;
+  while (cursor < ready.length) {
+    const key = ready[cursor];
+    if (key === undefined) {
+      break;
+    }
+    cursor += 1;
+    const object = byKey.get(key);
+    if (object === undefined) {
+      catalogError2("OKM1020", "Dependency order lost an object while sorting.");
+    }
+    ordered.push(object);
+    for (const dependent of dependents.get(key) ?? []) {
+      const left = (remaining.get(dependent) ?? 0) - 1;
+      remaining.set(dependent, left);
+      if (left === 0) {
+        insertSorted(ready, cursor, dependent);
+      }
+    }
+  }
+  if (ordered.length !== byKey.size) {
+    catalogError2("OKM1026", "Catalog has a dependency cycle.");
+  }
+  return ordered;
+}
+function insertSorted(ready, from, key) {
+  let index = from;
+  while (index < ready.length && compareText(ready[index] ?? "", key) < 0) {
+    index += 1;
+  }
+  ready.splice(index, 0, key);
+}
+
+// src/contracts/catalog/build.ts
+function catalog(objects) {
+  for (const object of objects) {
+    if (object.kind !== object.identity.kind) {
+      catalogError2("OKM1020", `${identityLabel2(object.identity)} has kind ${object.kind}.`);
+    }
+  }
+  const indexed = indexObjects(objects);
+  const keys = new Set;
+  for (const item of indexed) {
+    keys.add(item.key);
+  }
+  assertForeignKeys(objects, keys);
+  orderIndexed(indexed);
+  const sorted = [...indexed].sort((left, right) => compareText(left.key, right.key));
+  return { version: CATALOG_VERSION2, objects: sorted.map((item) => item.object) };
+}
+function assertForeignKeys(objects, keys) {
+  for (const object of objects) {
+    if (object.kind !== "constraint" || object.definition.constraintKind !== "foreignKey") {
+      continue;
+    }
+    const references = object.definition.references;
+    if (references === undefined) {
+      catalogError2("OKM1021", `Foreign key ${object.identity.name} is missing its target.`);
+    }
+    const tableKey = identityKey2({
+      kind: "table",
+      namespace: references.parent.namespace,
+      name: references.parent.name
+    });
+    if (!keys.has(tableKey)) {
+      catalogError2("OKM1021", `Foreign key ${object.identity.name} references missing table ${references.parent.name}.`);
+    }
+    for (const name of references.columns) {
+      const columnKey = identityKey2({ kind: "column", parent: references.parent, name });
+      if (!keys.has(columnKey)) {
+        catalogError2("OKM1021", `Foreign key ${object.identity.name} references missing column ${name}.`);
+      }
+    }
+  }
+}
+
+// src/contracts/catalog/enum.ts
+function enumType(input) {
+  assertNamespace2(input.namespace);
+  assertIdentifier2(input.name, "type");
+  assertProvenance(input.provenance);
+  if (input.labels.length === 0) {
+    catalogError2("OKM1020", `Enum ${input.name} must list at least one label.`);
+  }
+  const labels = [];
+  const seen = new Set;
+  for (const label of input.labels) {
+    assertStoredText(label, "enum label");
+    if (label.length === 0) {
+      catalogError2("OKM1020", `Enum ${input.name} has an empty label.`);
+    }
+    if (seen.has(label)) {
+      catalogError2("OKM1020", `Enum ${input.name} repeats label ${label}.`);
+    }
+    seen.add(label);
+    labels.push(label);
+  }
+  const identity = {
+    kind: "type",
+    namespace: input.namespace,
+    name: input.name
+  };
+  return {
+    kind: "type",
+    identity,
+    owner: input.owner ?? "managed",
+    definition: { labels },
+    dependencies: normaliseEdges(input.dependencies ?? []),
+    provenance: input.provenance
+  };
+}
+function sameEnumLabels(left, right) {
+  if (left.length !== right.length)
+    return false;
+  for (let index = 0;index < left.length; index += 1) {
+    if (left[index] !== right[index])
+      return false;
+  }
+  return true;
+}
+
+export { dependencyOrder, catalog, enumType, sameEnumLabels };