okmodel 0.1.0 → 0.2.1

package/dist/shared/{7ck0dtry.js → ecdzej21.js}

@@ -1,16 +1,95 @@
 import {
   POSTGRESJS_CAPABILITIES,
-  driverErrors,
   rejectClosed,
   mapFailure,
   nextTransactionDepth,
   runCall,
   EMPTY_NOTICES,
   resultFrom
-} from "./xy79j5hq.js";
+} from "./9k6vetvf.js";
 
 // src/adapters/pg/postgresjs.ts
+import net from "node:net";
 import postgres from "postgres";
+class PoolSockets {
+  held = [];
+  busy = 0;
+  listeners = 0;
+  hostCursor = 0;
+  connect(target) {
+    const path = typeof target.path === "string" ? target.path : undefined;
+    const hosts = target.host;
+    const ports = target.port;
+    const index = hosts.length === 0 ? 0 : this.hostCursor % hosts.length;
+    this.hostCursor += 1;
+    const host = hosts[index] ?? "localhost";
+    const port = ports[index] ?? ports[0] ?? 5432;
+    const socket = path !== undefined ? net.connect(path) : net.connect(port, host);
+    this.held.push(socket);
+    return socket;
+  }
+  occupy(run) {
+    this.busy += 1;
+    this.wake();
+    return run().finally(() => {
+      this.busy -= 1;
+      this.park();
+    });
+  }
+  busyGate() {
+    return {
+      enter: () => {
+        this.busy += 1;
+        this.wake();
+      },
+      leave: () => {
+        this.busy -= 1;
+        this.park();
+      }
+    };
+  }
+  listenerGate() {
+    return {
+      enter: () => {
+        this.listeners += 1;
+        this.wake();
+      },
+      leave: () => {
+        this.listeners -= 1;
+        this.park();
+      }
+    };
+  }
+  wake() {
+    for (const socket of this.held)
+      socket.ref();
+  }
+  park() {
+    if (this.busy > 0 || this.listeners > 0)
+      return;
+    for (const socket of this.held)
+      socket.unref();
+  }
+}
+function driverOptions(config, state) {
+  return {
+    max: state.max,
+    prepare: state.named,
+    idle_timeout: state.plain ? 0 : 30,
+    ...state.plain ? { max_lifetime: null } : {},
+    connect_timeout: 5,
+    types: WIRE_TYPES,
+    ...state.plain ? { socket: (options) => state.sockets.connect(options) } : {},
+    ...config.ssl !== undefined ? { ssl: config.ssl } : {},
+    connection: {
+      application_name: "okmodel",
+      ...config.searchPath !== undefined ? { search_path: config.searchPath } : {}
+    },
+    onnotice(notice) {
+      state.notices.push(notice);
+    }
+  };
+}
 function open2(config) {
   const max = config.max ?? 10;
   const acquireMs = config.timeouts?.acquire;
@@ -20,47 +99,65 @@ function open2(config) {
   let closed = false;
   const isClosed = () => closed;
   const named = config.prepared === "named";
-  const sql = postgres(config.url, {
+  const plain = config.ssl === undefined;
+  const sockets = new PoolSockets;
+  const sql = postgres(config.url, driverOptions(config, {
     max,
-    prepare: named,
-    idle_timeout: 30,
-    connect_timeout: 5,
-    types: WIRE_TYPES,
-    ...config.ssl !== undefined ? { ssl: config.ssl } : {},
-    connection: {
-      application_name: "okmodel",
-      ...config.searchPath !== undefined ? { search_path: config.searchPath } : {}
-    },
-    onnotice(notice) {
-      notices.push(notice);
-    }
-  });
+    named,
+    plain,
+    notices,
+    sockets
+  }));
   const root = new PgSession(sql, counters, "pool", poolInflight, isClosed, undefined, notices, named);
   const held = { sql, acquireMs, counters, isClosed, notices, named, poolInflight };
   return {
     capabilities: POSTGRESJS_CAPABILITIES,
     execute(text, params, options) {
-      return runCall(closed, options, (watch) => root.query(text, params, watch));
+      return sockets.occupy(() => runCall(closed, options, (watch) => root.query(text, params, watch)));
     },
     async batch(statements, options) {
-      const { checkout } = await import("./tb4ze1tr.js");
-      const connection = await checkout(held);
-      try {
-        return await connection.batch(statements, options);
-      } finally {
-        await connection.release();
-      }
+      return sockets.occupy(async () => {
+        const { checkout } = await import("./1dp5knt7.js");
+        const connection = await checkout(held);
+        try {
+          return await connection.batch(statements, options);
+        } finally {
+          await connection.release();
+        }
+      });
     },
-    reserve: () => import("./tb4ze1tr.js").then((mod) => mod.checkout(held)),
-    describe: (text, params) => import("./tb4ze1tr.js").then((mod) => mod.describe(sql, text, params)),
+    reserve() {
+      const gate = sockets.busyGate();
+      gate.enter();
+      return import("./1dp5knt7.js").then((mod) => mod.holdCheckout(gate, () => mod.checkout(held)), (error) => {
+        gate.leave();
+        throw error;
+      });
+    },
+    describe: (text, params) => sockets.occupy(() => import("./1dp5knt7.js").then((mod) => mod.describe(sql, text, params))),
     stream(text, params) {
-      return loadStream(sql, text, params);
+      const gate = sockets.busyGate();
+      return async function* () {
+        gate.enter();
+        try {
+          yield* loadStream(sql, text, params);
+        } finally {
+          gate.leave();
+        }
+      }();
     },
-    async listen(channel, onNotify) {
-      const listening = await sql.listen(channel, onNotify);
-      return async () => {
-        await listening.unlisten();
-      };
+    listen(channel, onNotify) {
+      const gate = sockets.listenerGate();
+      gate.enter();
+      return import("./1dp5knt7.js").then((mod) => mod.holdListener(gate, async () => {
+        const listening = await sql.listen(channel, onNotify);
+        return async () => {
+          await listening.unlisten();
+        };
+      }), (error) => {
+        gate.leave();
+        throw error;
+      });
     },
     cancel() {
       for (const pending of poolInflight)
@@ -113,7 +210,36 @@ class PgSession {
         });
       });
     }
-    return this.watched(pending, watch, start, text);
+    this.local.add(pending);
+    this.shared?.add(pending);
+    const onAbort = () => {
+      pending.cancel();
+    };
+    if (watch.signal.aborted)
+      onAbort();
+    else
+      watch.signal.addEventListener("abort", onAbort, { once: true });
+    return import("./1dp5knt7.js").then((mod) => mod.watchQuery(pending, watch, onAbort, {
+      start,
+      text,
+      notices: this.notices,
+      leave: () => {
+        this.leave();
+      },
+      note: (sqlText) => {
+        this.note(sqlText);
+      },
+      untrack: (item) => {
+        this.local.delete(item);
+        this.shared?.delete(item);
+      }
+    }), (error) => {
+      this.leave();
+      this.local.delete(pending);
+      this.shared?.delete(pending);
+      watch.signal.removeEventListener("abort", onAbort);
+      throw error;
+    });
   }
   inTransaction() {
     return this.transactionDepth > 0;
@@ -143,43 +269,9 @@ class PgSession {
     else
       this.counters.reservedBusy = Math.max(0, this.counters.reservedBusy - 1);
   }
-  track(pending) {
-    this.local.add(pending);
-    this.shared?.add(pending);
-  }
-  untrack(pending) {
-    this.local.delete(pending);
-    this.shared?.delete(pending);
-  }
-  watched(pending, watch, start, text) {
-    this.track(pending);
-    const onAbort = () => {
-      pending.cancel();
-    };
-    if (watch.signal.aborted)
-      onAbort();
-    else
-      watch.signal.addEventListener("abort", onAbort, { once: true });
-    return pending.then((result) => {
-      this.finishWatched(pending, watch, onAbort);
-      const why = watch.reason();
-      if (why === "timeout" || why === "cancelled")
-        return classify(why, watch);
-      this.note(text);
-      return resultFrom(result, this.notices.since(start));
-    }, (error) => {
-      this.finishWatched(pending, watch, onAbort);
-      return classify(error, watch);
-    });
-  }
-  finishWatched(pending, watch, onAbort) {
-    this.leave();
-    this.untrack(pending);
-    watch.signal.removeEventListener("abort", onAbort);
-  }
 }
 async function* loadStream(sql, text, params) {
-  const { stream } = await import("./tb4ze1tr.js");
+  const { stream } = await import("./1dp5knt7.js");
   yield* stream(sql, text, params);
 }
 function send(sql, text, params, named) {
@@ -192,19 +284,6 @@ function asParams(params) {
     return [];
   return params;
 }
-async function classify(error, watch) {
-  const errors = await driverErrors();
-  if (error instanceof errors.DriverError)
-    return Promise.reject(error);
-  const why = typeof error === "string" ? error : watch.reason();
-  if (why === "timeout")
-    return Promise.reject(errors.timedOut(typeof error === "string" ? undefined : error));
-  const code = errors.errorField(error, "code");
-  if (why === "cancelled" || code === "57014") {
-    return Promise.reject(errors.cancelled(typeof error === "string" ? undefined : error));
-  }
-  return Promise.reject(errors.mapDriverError(error));
-}
 function statsOf(counters, size) {
   return {
     size,

package/dist/shared/{px90pf9p.js → edwqqryd.js}

@@ -1,4 +1,5 @@
 import {
+  emitRelationFrom,
   decodeResult,
   emitJoin,
   emitWhere,
@@ -14,13 +15,15 @@ import {
   quote,
   list,
   isRecord,
+  registerFailFix,
   fail
-} from "./f5thc1s0.js";
+} from "./xrfnq5k8.js";
 import {
   throwNamed2
-} from "./ycwz42az.js";
+} from "./52szzakm.js";
 
 // src/runtime/include.ts
+registerFailFix("OKM1105", "Pass limit on the include, or call .all(reason).");
 var INCLUDE_OPTIONS = ["all", "include", "limit", "orderBy", "select", "where"];
 function emitIncludeSelect(include, alias, sink, outputs, column) {
   const selected = include.columns;
@@ -130,11 +133,7 @@ function emitIncludeJoin(schema, include, sink, parentAlias, alias, depth) {
       emitNestedAggregate(schema, nested, sink, childAlias, depth + 1);
     }
     sink.text(") as item from ");
-    sink.text(quote(child.model.sql));
-    sink.text(" ");
-    sink.text(childAlias);
-    sink.text(" where ");
-    emitJoin(sink, parentAlias, childAlias, include.relation);
+    emitRelationFrom(schema, include.relation, child, sink, parentAlias, childAlias, depth + 1);
     emitWhere(schema, child, include.where, sink, childAlias, depth + 1, true);
     emitOrder(child, include.orderBy, sink, childAlias);
     if (include.orderBy === undefined && child.model.primary.length > 0) {
@@ -225,11 +224,7 @@ function emitNestedAggregate(schema, include, sink, alias, depth) {
   if (include.columns.length === 0)
     sink.text("1");
   sink.text(") as item from ");
-  sink.text(quote(child.model.sql));
-  sink.text(" ");
-  sink.text(childAlias);
-  sink.text(" where ");
-  emitJoin(sink, alias, childAlias, include.relation);
+  emitRelationFrom(schema, include.relation, child, sink, alias, childAlias, depth);
   emitWhere(schema, child, include.where, sink, childAlias, depth, true);
   emitOrder(child, include.orderBy, sink, childAlias);
   if (include.orderBy === undefined && child.model.primary.length > 0) {
@@ -242,6 +237,14 @@ function emitNestedAggregate(schema, include, sink, alias, depth) {
   }
   sink.text(") limited) ordered)");
 }
+function omitHidden(columns) {
+  for (const column of columns) {
+    if (!column.hidden)
+      continue;
+    return columns.filter((item) => !item.hidden);
+  }
+  return columns;
+}
 function readIncludes(schema, table, include, all) {
   if (include === undefined)
     return [];
@@ -264,7 +267,7 @@ function parseInclude(schema, name, relation, value, all) {
       fail("OKM1105", `Include ${name} is to-many and has no limit. Pass limit, or call .all(reason).`);
     }
     const child = childIndex(schema, relation);
-    const columns = selectedColumns(child, undefined);
+    const columns = omitHidden(selectedColumns(child, undefined));
     return {
       name,
       relation,
@@ -288,7 +291,7 @@ function parseInclude(schema, name, relation, value, all) {
     fail("OKM1105", `Include ${name} is to-many and has no limit. Pass limit, or call .all(reason).`);
   }
   const child = childIndex(schema, relation);
-  const columns = selectedColumns(child, value.select);
+  const columns = omitHidden(selectedColumns(child, value.select));
   const nestedValue = value.include;
   const nested = nestedValue === undefined ? [] : readIncludes(schema, child, nestedValue, reason);
   return {
@@ -304,10 +307,12 @@ function parseInclude(schema, name, relation, value, all) {
 }
 function anchored(table, columns) {
   const pk = table.model.primary[0];
-  const selected = pk === undefined ? -1 : columns.findIndex((column) => column.field === pk);
+  if (pk === undefined)
+    return { presence: undefined, anchor: 0 };
+  const selected = columns.findIndex((column) => column.field === pk);
   if (selected >= 0)
     return { presence: undefined, anchor: selected };
-  return { presence: pk === undefined ? undefined : table.columns.get(pk), anchor: columns.length };
+  return { presence: table.columns.get(pk), anchor: columns.length };
 }
 function childIndex(schema, relation) {
   const child = indexes(schema).get(relation.table);

package/dist/shared/{g2v6gnc8.js → eqmtn1bj.js}

@@ -1,12 +1,13 @@
 import {
   open2
-} from "./7ck0dtry.js";
+} from "./ecdzej21.js";
 import {
   catalogHash2
-} from "./y9m15dfv.js";
+} from "./d2whjz4k.js";
+import"./n442h54c.js";
 import {
   loadMigrations
-} from "./4j72449d.js";
+} from "./rtnaqre0.js";
 import {
   quoteIdent,
   planMigration,
@@ -15,13 +16,63 @@ import {
   selectTarget,
   projectHead,
   loadConfig
-} from "./kynx7vbm.js";
+} from "./5z4q2zda.js";
 import {
   OkmError2
-} from "./ycwz42az.js";
+} from "./52szzakm.js";
 
 // src/tooling/migrate/apply.ts
 import { join } from "node:path";
+
+// src/tooling/migrate/engine.ts
+var IDENT = String.raw`"(?:[^"]|"")+"|[A-Za-z_][\w$]*`;
+var DEFAULT_UUIDV7 = /\bdefault\s+uuidv7\s*\(\s*\)/i;
+var TABLE = new RegExp(String.raw`^\s*(?:create\s+table(?:\s+if\s+not\s+exists)?|alter\s+table(?:\s+if\s+exists)?(?:\s+only)?)\s+(?:(?:${IDENT})\.)?(${IDENT})`, "i");
+var COLUMN = new RegExp(String.raw`(${IDENT})\s+(?:uuid\b|set\s+default\b)`, "i");
+function findUuidV7Default(migrations) {
+  for (const migration of migrations) {
+    for (let stepIndex = 0;stepIndex < migration.steps.length; stepIndex += 1) {
+      const sql = migration.steps[stepIndex]?.sql ?? "";
+      if (!DEFAULT_UUIDV7.test(sql))
+        continue;
+      return { migrationId: migration.id, stepIndex, column: columnOf(sql) };
+    }
+  }
+  return;
+}
+async function assertUuidV7Available(connection, migrations) {
+  const found = findUuidV7Default(migrations);
+  if (found === undefined)
+    return;
+  const result = await connection.execute("select current_setting('server_version_num'), to_regprocedure('uuidv7()')::text");
+  const row = result.rows[0];
+  const major = Math.floor(Number(row?.[0] ?? "0") / 1e4);
+  const defined = row?.[1] !== null && row?.[1] !== undefined;
+  if (major >= 18 || defined)
+    return;
+  const where = found.column === undefined ? "A column" : `Column ${found.column}`;
+  throw new OkmError2("OKM1812", `${where} has a uuidv7() default (migration ${found.migrationId}, step ${String(found.stepIndex)}), and the server is PostgreSQL ${String(major)}. uuidv7() arrives in PostgreSQL 18. Nothing was changed.`, {
+    fix: {
+      summary: 'Either run PostgreSQL 18 and declare schema({ requires: { postgres: ">=18" } }), or use t.id({ default: "uuidv4" }) (or schema({ defaults: { id: "uuidv4" } })), which uses gen_random_uuid() and works on PostgreSQL 13 and newer. Then delete the migration that was not applied and generate it again.'
+    }
+  });
+}
+function columnOf(sql) {
+  const table = TABLE.exec(sql)?.[1];
+  if (table === undefined)
+    return;
+  const line = sql.split(`
+`).find((text) => DEFAULT_UUIDV7.test(text));
+  const column = line === undefined ? undefined : COLUMN.exec(line)?.[1];
+  if (column === undefined)
+    return;
+  return `${unquote(table)}.${unquote(column)}`;
+}
+function unquote(name) {
+  return name.startsWith('"') ? name.slice(1, -1).replaceAll('""', '"') : name;
+}
+
+// src/tooling/migrate/apply.ts
 var DEFAULT_LOCK_MS = 5000;
 var DEFAULT_STATEMENT_MS = 30000;
 var DEFAULT_RETRIES = 3;
@@ -100,6 +151,7 @@ async function applyTarget(request) {
     await lockTarget(connection, request.target);
     locked = true;
     request.onLocked?.();
+    await assertUuidV7Available(connection, request.migrations);
     await connection.execute(META);
     await connection.execute(HISTORY);
     const done = await readDone(connection);

package/dist/shared/g1b5zzj9.js

@@ -0,0 +1,75 @@
+import {
+  definition,
+  unavailable
+} from "./xatfg0gn.js";
+
+// src/dialects/pg/trait.ts
+var TRAIT_KEYS = new Set(["fields", "name", "presets", "sealed", "touch"]);
+function checkTrait(value, where) {
+  if (!isRecord(value))
+    definition(`${where} traits must be a list of traits.`);
+  for (const key of Object.keys(value)) {
+    if (key === "methods" || key === "requires") {
+      unavailable(`Trait option ${key} is not available yet. It arrives in 0.2.`);
+    }
+    if (!TRAIT_KEYS.has(key)) {
+      definition(`${where} trait option ${key} is not supported. Accepted options: fields, name, presets, sealed, touch.`);
+    }
+  }
+  const name = value.name;
+  if (typeof name !== "string" || name.length === 0)
+    definition(`${where} trait needs a name.`);
+  const fields = value.fields;
+  if (!isRecord(fields))
+    definition(`Trait ${name} needs a fields object.`);
+  const known = Object.keys(fields);
+  readNames(value.touch, name, "touch", known);
+  readNames(value.sealed, name, "sealed", known);
+  return value;
+}
+function contributedFields(schemaTraits, options) {
+  const chosen = choose(options?.omitDefaults === undefined ? schemaTraits : undefined, options?.traits);
+  if (chosen === undefined)
+    return [];
+  const pairs = [];
+  const seen = new Set;
+  for (const trait of chosen) {
+    for (const field of Object.keys(trait.fields)) {
+      if (seen.has(field))
+        continue;
+      const builder = trait.fields[field];
+      if (builder === undefined)
+        continue;
+      seen.add(field);
+      pairs.push([field, builder]);
+    }
+  }
+  return pairs;
+}
+function choose(schemaTraits, local) {
+  const shared = schemaTraits ?? [];
+  const own = local ?? [];
+  if (shared.length === 0 && own.length === 0)
+    return;
+  if (own.length === 0)
+    return shared;
+  if (shared.length === 0)
+    return own;
+  return [...shared, ...own];
+}
+function readNames(value, traitName, label, known) {
+  if (value === undefined)
+    return;
+  if (!Array.isArray(value))
+    definition(`Trait ${traitName} ${label} must be a list of field names.`);
+  for (const field of value) {
+    if (typeof field === "string" && known.includes(field))
+      continue;
+    definition(`Trait ${traitName} ${label} names ${String(field)}, which is not one of its fields. Accepted fields: ${known.join(", ")}.`);
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export { checkTrait, contributedFields };