okmodel 0.1.1 → 0.2.1

package/dist/shared/{dkn3y60a.js → ecdzej21.js}

@@ -1,13 +1,12 @@
 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";
@@ -37,61 +36,29 @@ class PoolSockets {
       this.park();
     });
   }
-  async hold(checkout) {
-    this.busy += 1;
-    this.wake();
-    try {
-      const connection = await checkout();
-      let released = false;
-      const release = connection.release.bind(connection);
-      connection.release = () => {
-        if (released)
-          return Promise.resolve();
-        released = true;
-        return release().finally(() => {
-          this.busy -= 1;
-          this.park();
-        });
-      };
-      return connection;
-    } catch (error) {
-      this.busy -= 1;
-      this.park();
-      throw error;
-    }
-  }
-  async* stream(open) {
-    this.busy += 1;
-    this.wake();
-    try {
-      yield* open();
-    } finally {
-      this.busy -= 1;
-      this.park();
-    }
+  busyGate() {
+    return {
+      enter: () => {
+        this.busy += 1;
+        this.wake();
+      },
+      leave: () => {
+        this.busy -= 1;
+        this.park();
+      }
+    };
   }
-  async listen(start) {
-    this.listeners += 1;
-    this.wake();
-    try {
-      const stop = await start();
-      let stopped = false;
-      return async () => {
-        if (stopped)
-          return;
-        stopped = true;
-        try {
-          await stop();
-        } finally {
-          this.listeners -= 1;
-          this.park();
-        }
-      };
-    } catch (error) {
-      this.listeners -= 1;
-      this.park();
-      throw error;
-    }
+  listenerGate() {
+    return {
+      enter: () => {
+        this.listeners += 1;
+        this.wake();
+      },
+      leave: () => {
+        this.listeners -= 1;
+        this.park();
+      }
+    };
   }
   wake() {
     for (const socket of this.held)
@@ -150,7 +117,7 @@ function open2(config) {
     },
     async batch(statements, options) {
       return sockets.occupy(async () => {
-        const { checkout } = await import("./xqbhg6cn.js");
+        const { checkout } = await import("./1dp5knt7.js");
         const connection = await checkout(held);
         try {
           return await connection.batch(statements, options);
@@ -160,21 +127,36 @@ function open2(config) {
       });
     },
     reserve() {
-      return sockets.hold(async () => {
-        const mod = await import("./xqbhg6cn.js");
-        return mod.checkout(held);
+      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("./xqbhg6cn.js").then((mod) => mod.describe(sql, text, params))),
+    describe: (text, params) => sockets.occupy(() => import("./1dp5knt7.js").then((mod) => mod.describe(sql, text, params))),
     stream(text, params) {
-      return sockets.stream(() => loadStream(sql, text, params));
+      const gate = sockets.busyGate();
+      return async function* () {
+        gate.enter();
+        try {
+          yield* loadStream(sql, text, params);
+        } finally {
+          gate.leave();
+        }
+      }();
     },
     listen(channel, onNotify) {
-      return sockets.listen(async () => {
+      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() {
@@ -228,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;
@@ -258,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("./xqbhg6cn.js");
+  const { stream } = await import("./1dp5knt7.js");
   yield* stream(sql, text, params);
 }
 function send(sql, text, params, named) {
@@ -307,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/{hadrfb9h.js → edwqqryd.js}

@@ -1,4 +1,5 @@
 import {
+  emitRelationFrom,
   decodeResult,
   emitJoin,
   emitWhere,
@@ -14,13 +15,15 @@ import {
   quote,
   list,
   isRecord,
+  registerFailFix,
   fail
-} from "./rgs0st28.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 {

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

@@ -1,12 +1,13 @@
 import {
   open2
-} from "./dkn3y60a.js";
+} from "./ecdzej21.js";
 import {
   catalogHash2
-} from "./y9m15dfv.js";
+} from "./d2whjz4k.js";
+import"./n442h54c.js";
 import {
   loadMigrations
-} from "./jjb7yht9.js";
+} from "./rtnaqre0.js";
 import {
   quoteIdent,
   planMigration,
@@ -15,13 +16,63 @@ import {
   selectTarget,
   projectHead,
   loadConfig
-} from "./05w44d8g.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 };