okmodel 0.8.0 → 0.9.1

package/dist/shared/py2zrrm6.js

@@ -0,0 +1,451 @@
+import {
+  open2
+} from "./jvxcp1qk.js";
+import"./12z7aznj.js";
+import"./n442h54c.js";
+import"./fk9vef30.js";
+import {
+  openProject
+} from "./wp7y8q3y.js";
+import {
+  driverUrl,
+  sessionFailure,
+  finishQuiet,
+  assertTargetPolicy,
+  selectTarget
+} from "./bdekbvmt.js";
+import {
+  isExactVersion,
+  compareExtensionVersions
+} from "./r3j8s5y0.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/tooling/migrate/ext.ts
+import { existsSync, writeFileSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+// src/tooling/migrate/ext-surface.ts
+var INSTALLED = `
+  select e.extversion, n.nspname, e.extrelocatable::text, current_setting('server_version_num')
+  from pg_extension e
+  join pg_namespace n on n.oid = e.extnamespace
+  where e.extname = $1
+`;
+var TYPES = `
+  select t.typname
+  from pg_depend d
+  join pg_extension e on e.oid = d.refobjid
+  join pg_type t on t.oid = d.objid
+  where e.extname = $1
+    and d.deptype = 'e'
+    and d.classid = 'pg_type'::regclass
+    and t.typtype in ('b', 'e', 'd', 'c')
+  order by t.typname
+`;
+var FUNCTIONS = `
+  select p.proname,
+         pg_get_function_identity_arguments(p.oid),
+         pg_get_function_result(p.oid)
+  from pg_depend d
+  join pg_extension e on e.oid = d.refobjid
+  join pg_proc p on p.oid = d.objid
+  where e.extname = $1
+    and d.deptype = 'e'
+    and d.classid = 'pg_proc'::regclass
+  order by p.proname, pg_get_function_identity_arguments(p.oid)
+`;
+var OPERATORS = `
+  select o.oprname,
+         coalesce(l.typname, ''),
+         coalesce(r.typname, ''),
+         res.typname
+  from pg_depend d
+  join pg_extension e on e.oid = d.refobjid
+  join pg_operator o on o.oid = d.objid
+  left join pg_type l on l.oid = o.oprleft
+  left join pg_type r on r.oid = o.oprright
+  join pg_type res on res.oid = o.oprresult
+  where e.extname = $1
+    and d.deptype = 'e'
+    and d.classid = 'pg_operator'::regclass
+  order by o.oprname, l.typname, r.typname
+`;
+var OPCLASSES = `
+  select am.amname, oc.opcname
+  from pg_depend d
+  join pg_extension e on e.oid = d.refobjid
+  join pg_opclass oc on oc.oid = d.objid
+  join pg_am am on am.oid = oc.opcmethod
+  where e.extname = $1
+    and d.deptype = 'e'
+    and d.classid = 'pg_opclass'::regclass
+  order by am.amname, oc.opcname
+`;
+var SETTINGS = `
+  select name from pg_settings where name like $1 order by name
+`;
+async function readSurface(pool, name) {
+  const installed = await pool.execute(INSTALLED, [name]);
+  const row = installed.rows[0];
+  if (row === undefined) {
+    throw new OkmError2("OKM1811", `Extension ${name} is not installed on the server.`, {
+      fix: { summary: "Install the extension, then run okm ext scaffold again." }
+    });
+  }
+  const version = text(row[0]);
+  const schema = text(row[1]);
+  const relocatable = row[2] === "t" || row[2] === "true";
+  const serverMajor = majorOf(text(row[3]));
+  const [types, functions, operators, methods, settings] = await Promise.all([
+    pool.execute(TYPES, [name]),
+    pool.execute(FUNCTIONS, [name]),
+    pool.execute(OPERATORS, [name]),
+    pool.execute(OPCLASSES, [name]),
+    pool.execute(SETTINGS, [`${name}.%`])
+  ]);
+  return {
+    name,
+    version,
+    schema,
+    relocatable,
+    serverMajor,
+    types: types.rows.map((item) => ({ name: text(item[0]) })),
+    functions: functions.rows.flatMap((item) => callable(item)),
+    operators: operators.rows.flatMap((item) => visibleOperator(item)),
+    indexMethods: methods.rows.map((item) => ({
+      name: text(item[0]),
+      opclass: text(item[1])
+    })),
+    settings: settings.rows.map((item) => text(item[0]))
+  };
+}
+function renderScaffold(surface) {
+  const exportName = `${camel(surface.name)}Ext`;
+  const settings = surface.settings.length === 0 ? "none" : surface.settings.join(", ");
+  const body = {
+    schema: surface.schema,
+    relocatable: surface.relocatable,
+    requires: {
+      postgres: ">=15",
+      version: `>=${surface.version}`
+    },
+    provides: {
+      types: surface.types,
+      operators: surface.operators,
+      functions: surface.functions,
+      indexMethods: surface.indexMethods
+    }
+  };
+  return [
+    'import { extension } from "okmodel/ext";',
+    "",
+    "/**",
+    ` * Starting definition for ${surface.name} ${surface.version} in schema ${surface.schema}.`,
+    " * Edit this file. okm ext test checks it against the connected server.",
+    ` * Settings: ${settings}.`,
+    " */",
+    `export const ${exportName} = extension(${JSON.stringify(surface.name)}, ${JSON.stringify(body, null, 2)});`,
+    ""
+  ].join(`
+`);
+}
+function surfaceMismatches(declared, server) {
+  const lines = [];
+  lines.push(...versionMismatches(declared, server));
+  const provides = declared.provides;
+  if (provides === undefined)
+    return lines;
+  for (const type of provides.types ?? []) {
+    if (!server.types.some((item) => item.name === type.name)) {
+      lines.push(`type ${type.name} is not in ${declared.name}`);
+    }
+  }
+  for (const operator of provides.operators ?? []) {
+    if (!operatorMatches(operator, server.operators)) {
+      lines.push(operatorLine(operator));
+    }
+  }
+  for (const fn of provides.functions ?? []) {
+    if (!functionMatches(fn, server.functions)) {
+      lines.push(`function ${fn.name}(${fn.args.join(", ")}) -> ${fn.returns}`);
+    }
+  }
+  for (const method of provides.indexMethods ?? []) {
+    if (!methodMatches(method, server.indexMethods)) {
+      const opclass = method.opclass === undefined ? "" : ` ${method.opclass}`;
+      lines.push(`index method ${method.name}${opclass}`);
+    }
+  }
+  return lines;
+}
+function refuseMismatches(name, mismatches) {
+  if (mismatches.length === 0)
+    return;
+  const version = mismatches.some((line) => line.startsWith("version ") || line.startsWith("postgres "));
+  const code = version ? "OKM1812" : "invalid";
+  throw new OkmError2(code, `Extension ${name} does not match the server.
+${mismatches.join(`
+`)}`, {
+    fix: {
+      summary: "Edit the definition so each signature matches the server, or install the version requires names."
+    }
+  });
+}
+function versionMismatches(declared, server) {
+  const lines = [];
+  const requires = {
+    ...declared.requires,
+    ...declared.version !== undefined ? { version: declared.version } : {}
+  };
+  const postgres = requires.postgres;
+  if (postgres !== undefined && !majorAllows(postgres, server.serverMajor)) {
+    lines.push(`postgres ${postgres} is not met. The server is PostgreSQL ${String(server.serverMajor)}. minPostgres: ${floorText(postgres)}.`);
+  }
+  const version = requires.version;
+  if (version !== undefined && !versionAllows(version, server.version)) {
+    lines.push(`version ${version} is not met. The server has ${server.version}.`);
+  }
+  return lines;
+}
+function majorAllows(declared, server) {
+  const floor = /^>=(\d+)$/.exec(declared);
+  const exact = floor?.[1] ?? (/^\d+$/.test(declared) ? declared : undefined);
+  if (exact === undefined)
+    return false;
+  return server >= Number(exact);
+}
+function versionAllows(declared, installed) {
+  const floor = /^>=(\d+(?:\.\d+)*)$/.exec(declared);
+  const pinned = floor?.[1] ?? declared;
+  if (!isExactVersion(pinned) || !isExactVersion(installed))
+    return declared === installed;
+  return compareExtensionVersions(installed, pinned) >= 0;
+}
+function floorText(declared) {
+  return declared.startsWith(">=") ? declared.slice(2) : declared;
+}
+function operatorMatches(declared, server) {
+  return server.some((item) => item.name === declared.name && (declared.left === undefined || item.left === declared.left) && (declared.right === undefined || item.right === declared.right) && item.result === declared.result);
+}
+function functionMatches(declared, server) {
+  const args = declared.args.join(", ");
+  return server.some((item) => item.name === declared.name && item.args.join(", ") === args && item.returns === declared.returns);
+}
+function methodMatches(declared, server) {
+  return server.some((item) => item.name === declared.name && (declared.opclass === undefined || item.opclass === declared.opclass));
+}
+function operatorLine(operator) {
+  const left = operator.left ?? "";
+  const right = operator.right ?? "";
+  return `operator ${left} ${operator.name} ${right} -> ${operator.result}`.replaceAll(/\s+/g, " ").trim();
+}
+function callable(row) {
+  const args = text(row[1]);
+  const returns = text(row[2]);
+  if (args.includes("internal") || returns.includes("internal"))
+    return [];
+  return [
+    {
+      name: text(row[0]),
+      args: args.length === 0 ? [] : args.split(", ").filter((part) => part.length > 0),
+      returns
+    }
+  ];
+}
+function visibleOperator(row) {
+  const left = text(row[1]);
+  const right = text(row[2]);
+  const result = text(row[3]);
+  if ([left, right, result].some((part) => part === "internal"))
+    return [];
+  return [
+    {
+      name: text(row[0]),
+      ...left.length > 0 ? { left } : {},
+      ...right.length > 0 ? { right } : {},
+      result
+    }
+  ];
+}
+function text(value) {
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  return "";
+}
+function majorOf(versionNum) {
+  const parsed = Number(versionNum);
+  if (!Number.isFinite(parsed))
+    return 0;
+  return Math.floor(parsed / 1e4);
+}
+function camel(name) {
+  const parts = name.split(/[^A-Za-z0-9]+/).filter((part) => part.length > 0);
+  const [first, ...rest] = parts;
+  if (first === undefined)
+    return "extension";
+  return first.toLowerCase() + rest.map((part) => part.slice(0, 1).toUpperCase() + part.slice(1).toLowerCase()).join("");
+}
+function isExtension(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  if (!("name" in value) || !("contribute" in value) || !("schema" in value))
+    return false;
+  return typeof value.name === "string" && typeof value.contribute === "function";
+}
+function extensionsFromModule(imported) {
+  if (typeof imported !== "object" || imported === null)
+    return [];
+  const found = [];
+  for (const value of Object.values(imported)) {
+    if (isExtension(value))
+      found.push(value);
+  }
+  return found;
+}
+
+// src/tooling/migrate/ext.ts
+async function extProject(cwd, command, flags) {
+  const opened = await openProject(cwd);
+  const target = selectTarget(opened.config, flags.target);
+  assertTargetPolicy(target, "check", flags.allowProtected);
+  const pool = open2({ url: driverUrl(target.url), max: 1 });
+  try {
+    if (command === "list")
+      return formatList(await readExtensions(pool));
+    return formatCheck(opened.built.catalog.objects, await readExtensions(pool));
+  } catch (error) {
+    throw sessionFailure(error) ?? error;
+  } finally {
+    await finishQuiet(() => pool.close());
+  }
+}
+var LIST_SQL = `
+  select a.name, a.default_version, e.extversion, n.nspname
+  from pg_available_extensions a
+  left join pg_extension e on e.extname = a.name
+  left join pg_namespace n on n.oid = e.extnamespace
+  order by a.name
+`;
+async function readExtensions(pool) {
+  const result = await pool.execute(LIST_SQL);
+  return result.rows.map((row) => ({
+    name: cell(row[0]),
+    defaultVersion: cell(row[1]),
+    installedVersion: cell(row[2]),
+    schema: cell(row[3])
+  }));
+}
+function cell(value) {
+  return typeof value === "string" ? value : "";
+}
+function formatList(rows) {
+  const lines = ["name\tdefault\tinstalled\tschema"];
+  for (const row of rows) {
+    lines.push([row.name, row.defaultVersion, row.installedVersion, row.schema].join("\t"));
+  }
+  return `${lines.join(`
+`)}
+`;
+}
+function formatCheck(objects, server) {
+  const declared = objects.filter((object) => object.kind === "extension");
+  if (declared.length === 0)
+    return `no extensions
+`;
+  const installed = new Map(server.map((row) => [row.name, row.installedVersion]));
+  const lines = ["name\tdeclared\tinstalled"];
+  for (const object of [...declared].sort((left, right) => left.identity.name < right.identity.name ? -1 : 1)) {
+    const name = object.identity.name;
+    const have = installed.get(name) ?? "";
+    if (have.length === 0) {
+      throw new OkmError2("OKM1811", `Extension ${name} is not installed on the server.`, {
+        fix: { summary: "Install the extension, or remove the declaration." }
+      });
+    }
+    const want = object.definition.version;
+    if (!versionAccepted(want, have)) {
+      throw new OkmError2("OKM1812", extensionNeeds(name, want ?? "", have), {
+        fix: { summary: "Install a version the declaration accepts, or change the pin." }
+      });
+    }
+    lines.push([name, want ?? "-", have].join("\t"));
+  }
+  return `${lines.join(`
+`)}
+`;
+}
+function extensionNeeds(name, want, have) {
+  const floor = /^>=(\d+(?:\.\d+)*)$/.exec(want);
+  const need = floor?.[1] ?? want;
+  const higher = floor === null ? "" : " or higher";
+  return `Extension ${name} needs ${need}${higher}. The server has ${have}. Install a version the declaration accepts, or change the pin.`;
+}
+async function extScaffold(cwd, name, flags, out) {
+  if (out !== undefined) {
+    const path = isAbsolute(out) ? out : join(cwd, out);
+    if (existsSync(path)) {
+      throw new OkmError2("invalid", `okm ext scaffold would overwrite ${path}. Nothing was written.`, { fix: { summary: "Pass a path that does not exist. The command never overwrites." } });
+    }
+  }
+  const text = await withServer(cwd, flags, async (pool) => renderScaffold(await readSurface(pool, name)));
+  if (out === undefined)
+    return text;
+  const path = isAbsolute(out) ? out : join(cwd, out);
+  writeFileSync(path, text);
+  return `wrote ${path}
+`;
+}
+async function extTest(cwd, file, flags) {
+  const path = isAbsolute(file) ? file : join(cwd, file);
+  const imported = await import(pathToFileURL(path).href);
+  const declared = extensionsFromModule(imported);
+  if (declared.length === 0) {
+    throw new OkmError2("invalid", `okm ext test found no extension() in ${path}.`, {
+      fix: { summary: "Export the value extension() returns." }
+    });
+  }
+  return withServer(cwd, flags, async (pool) => {
+    const lines = [];
+    for (const extension of declared) {
+      const server = await readSurface(pool, extension.name);
+      refuseMismatches(extension.name, surfaceMismatches(extension, server));
+      lines.push(`ok ${extension.name}`);
+    }
+    return `${lines.join(`
+`)}
+`;
+  });
+}
+async function withServer(cwd, flags, body) {
+  const opened = await openProject(cwd);
+  const target = selectTarget(opened.config, flags.target);
+  assertTargetPolicy(target, "check", flags.allowProtected);
+  const pool = open2({ url: driverUrl(target.url), max: 1 });
+  try {
+    return await body(pool);
+  } catch (error) {
+    throw sessionFailure(error) ?? error;
+  } finally {
+    await finishQuiet(() => pool.close());
+  }
+}
+function versionAccepted(declared, installed) {
+  if (declared === undefined)
+    return true;
+  const floor = /^>=(\d+(?:\.\d+)*)$/.exec(declared);
+  const minimum = floor?.[1];
+  if (minimum !== undefined) {
+    return isExactVersion(installed) && compareExtensionVersions(installed, minimum) >= 0;
+  }
+  return declared === installed;
+}
+export {
+  extProject,
+  extScaffold,
+  extTest
+};

package/dist/shared/{9dr2qnx7.js → qqm3ze6q.js}

@@ -17,7 +17,7 @@ import {
   snakeCase,
   emittedTypeName,
   rejectLater
-} from "./gcefca6p.js";
+} from "./f9t9g54z.js";
 import {
   ColumnBuilder2,
   formatType

package/dist/shared/{wvdjznah.js → rcjm0yn7.js}

@@ -4,12 +4,12 @@ import {
 import {
   send2,
   reserve,
-  park
-} from "./zbqbmmrp.js";
+  releaseReserved
+} from "./n6je5b28.js";
 import {
   resetSession2,
   refuseWhenLost2
-} from "./7ghwamrf.js";
+} from "./99qp9vtg.js";
 import {
   cursorStream
 } from "./7kms6fvj.js";
@@ -18,14 +18,14 @@ import {
 } from "./cnkky55j.js";
 import {
   noTimeout
-} from "./q0cqt2sp.js";
+} from "./tr64w5p0.js";
 import {
   WireSession
-} from "./mtw6jz76.js";
+} from "./e275q7sd.js";
 import {
   rejectClosed,
   runCall
-} from "./ae4j5f42.js";
+} from "./mfvx6kjx.js";
 
 // src/adapters/pg/bunsql-extra.ts
 async function recover(sql, error, text, depth, clientRead, closedDuring, again) {
@@ -62,19 +62,13 @@ function lostQuery(error) {
 function socketClosed(error) {
   if (!(error instanceof Error))
     return false;
-  if (error.message === "Connection closed")
+  if (bunClosed(error.message))
     return true;
-  return error.cause instanceof Error && error.cause.message === "Connection closed";
+  return error.cause instanceof Error && bunClosed(error.cause.message);
 }
-async function listen(sql, parked, closed, channel, onNotify) {
+async function listen(sql, closed, channel, onNotify) {
   if (closed)
     return rejectClosed();
-  const pending = parked.splice(0);
-  for (const reserved of pending) {
-    const done = reserved.release();
-    if (done instanceof Promise)
-      await done;
-  }
   const subscription = await sql.listen(channel, onNotify);
   return async () => {
     await subscription.unlisten();
@@ -84,7 +78,7 @@ async function checkout(held) {
   const { counters, isClosed } = held;
   if (isClosed())
     return rejectClosed();
-  const reserved = await takeOpen(held) ?? await reserve(held.sql, held.acquireMs, counters);
+  const reserved = await reserve(held.sql, held.acquireMs, counters);
   counters.reserved += 1;
   const session = new WireSession((text, params) => send2(reserved, text, params), held.notices, isClosed, false, () => {
     counters.reservedBusy += 1;
@@ -140,20 +134,33 @@ async function checkout(held) {
       try {
         if (!lost.on)
           await reset(session, reserved);
-      } catch (error) {
-        if (lostQuery(error) || reportsClosed(reserved))
-          lost.on = true;
-        else
-          throw error;
+        else if (session.depth() > 0 && !reportsClosed(reserved)) {
+          await reserved.unsafe("ROLLBACK").catch(() => {
+            return;
+          });
+          session.abandon();
+        }
+      } catch {
+        lost.on = true;
       } finally {
         counters.reserved = Math.max(0, counters.reserved - 1);
         if (lost.on) {
           try {
             reserved.release();
           } catch {}
-          await flushClosed(held.sql);
-        } else
-          await park(held.parked, reserved);
+          if (counters.reserved === 0)
+            await flushClosed(held.sql);
+        } else {
+          try {
+            await releaseReserved(reserved);
+          } catch {
+            try {
+              reserved.release();
+            } catch {}
+            if (counters.reserved === 0)
+              await flushClosed(held.sql);
+          }
+        }
       }
     }
   };
@@ -161,20 +168,6 @@ async function checkout(held) {
 function reportsClosed(reserved) {
   return Reflect.get(reserved, "closed") === true;
 }
-async function takeOpen(held) {
-  while (held.parked.length > 0) {
-    const next = held.parked.pop();
-    if (next === undefined)
-      return;
-    if (!reportsClosed(next))
-      return next;
-    try {
-      next.release();
-    } catch {}
-    await flushClosed(held.sql);
-  }
-  return;
-}
 async function flushClosed(sql) {
   for (let attempt = 0;attempt < 3; attempt += 1) {
     try {

package/dist/shared/rged92v6.js

@@ -0,0 +1,17 @@
+import {
+  assertAuthorDrift2,
+  sealDomainChecks2,
+  catalogQuery2,
+  managedRoleOptions2
+} from "./4pkz5nvw.js";
+import"./e1c55v04.js";
+import"./mz48rs74.js";
+import"./bdekbvmt.js";
+import"./fk9vef30.js";
+import"./12z7aznj.js";
+export {
+  assertAuthorDrift2 as assertAuthorDrift,
+  catalogQuery2 as catalogQuery,
+  managedRoleOptions2 as managedRoleOptions,
+  sealDomainChecks2 as sealDomainChecks
+};