okmodel 0.8.0 → 0.9.0

package/dist/shared/{g5yc06ka.js → s7he5e5d.js}

@@ -2,7 +2,7 @@ import {
   readHandle,
   readCall,
   attachHttp
-} from "./bah9nbg3.js";
+} from "./npdftanb.js";
 import {
   decodeResult,
   emitWhere,

package/dist/shared/{hfqmpasr.js → ss2kv2rs.js}

@@ -1,17 +1,18 @@
 import {
   open2
-} from "./35q0n9tz.js";
+} from "./dd5pmnky.js";
 import"./12z7aznj.js";
+import"./fk9vef30.js";
 import {
   createdOf,
   testing2
-} from "./b6d6p0zc.js";
+} from "./2szgv6yj.js";
 import"./n442h54c.js";
 import {
   projectPath,
   loadConfig,
   loadSchema
-} from "./f4jy1j7x.js";
+} from "./2zdxkt7b.js";
 import {
   sessionFailure,
   finishQuiet,
@@ -19,8 +20,7 @@ import {
   assertDirectConnection,
   assertStableBackend,
   selectTarget
-} from "./dpc2r7rb.js";
-import"./sjk86yrx.js";
+} from "./6nae0spm.js";
 import {
   OkmError2
 } from "./52szzakm.js";

package/dist/shared/stfa9xcw.js

@@ -0,0 +1,450 @@
+import {
+  open2
+} from "./dd5pmnky.js";
+import"./12z7aznj.js";
+import"./n442h54c.js";
+import"./fk9vef30.js";
+import {
+  openProject
+} from "./2zdxkt7b.js";
+import {
+  sessionFailure,
+  finishQuiet,
+  assertTargetPolicy,
+  selectTarget
+} from "./6nae0spm.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')
+  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: 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: 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/{tooling/shared/rs1jb051.js → shared/tr64w5p0.js}

@@ -1,6 +1,6 @@
 import {
   rejectUncancellable
-} from "./xhrnjch9.js";
+} from "./mfvx6kjx.js";
 
 // src/adapters/pg/no-inflight-timeout.ts
 function noTimeout(options) {

package/dist/shared/{jebgrkeq.js → tw1nvvfj.js}

@@ -1,9 +1,9 @@
 import {
   build3
-} from "./n0jmpgj1.js";
+} from "./cexb7z6b.js";
 import {
   attachHttp
-} from "./bah9nbg3.js";
+} from "./npdftanb.js";
 import {
   rejectKeys,
   readLimit,

package/dist/shared/{v1wad97q.js → wvtjg5m3.js}

@@ -8,7 +8,7 @@ import {
   openClient,
   withHttp,
   settleCall
-} from "./bah9nbg3.js";
+} from "./npdftanb.js";
 import {
   rejectKeys,
   isRecord,

package/dist/shared/xqacq37x.js

@@ -0,0 +1,61 @@
+import {
+  quotedIdent
+} from "./h9811jjm.js";
+import {
+  sqlExpression
+} from "./bsek72fg.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/dialects/pg/ext/call.ts
+function fnEqualsArg(schema, name, value) {
+  const fn = `${quotedIdent(schema)}.${quotedIdent(name)}`;
+  return sqlExpression([
+    { k: "t", s: `${fn}(` },
+    { k: "c" },
+    { k: "t", s: `) = ${fn}(` },
+    { k: "p", v: value },
+    { k: "t", s: ")" }
+  ], true);
+}
+function fnDistance(schema, name, value, distance) {
+  if (!Number.isInteger(distance)) {
+    throw new OkmError2("OKM1120", `${name} distance must be an integer.`, {
+      fix: { summary: "Pass a whole number of edits." }
+    });
+  }
+  const fn = `${quotedIdent(schema)}.${quotedIdent(name)}`;
+  return sqlExpression([
+    { k: "t", s: `${fn}(` },
+    { k: "c" },
+    { k: "t", s: ", " },
+    { k: "p", v: value },
+    { k: "t", s: ") = " },
+    { k: "p", v: String(distance) },
+    { k: "t", s: "::integer" }
+  ], true);
+}
+function opArg(op, value, cast) {
+  const parts = [{ k: "c" }, { k: "t", s: ` ${op} ` }, { k: "p", v: value }];
+  if (cast !== undefined)
+    parts.push({ k: "t", s: `::${cast}` });
+  return sqlExpression(parts, true);
+}
+function bareCall(schema, name) {
+  const fn = `${quotedIdent(schema)}.${quotedIdent(name)}`;
+  return sqlExpression([{ k: "t", s: `${fn}()` }], true);
+}
+function digestEquals(schema, algorithm, hex) {
+  const fn = `${quotedIdent(schema)}.${quotedIdent("digest")}`;
+  return sqlExpression([
+    { k: "t", s: `encode(${fn}(` },
+    { k: "c" },
+    { k: "t", s: ", " },
+    { k: "p", v: algorithm },
+    { k: "t", s: "), 'hex') = " },
+    { k: "p", v: hex }
+  ], true);
+}
+
+export { fnEqualsArg, fnDistance, opArg, bareCall, digestEquals };

package/dist/shared/{n05z9nwz.js → xtsydxjg.js}

@@ -3,7 +3,7 @@ import {
   readHandle,
   readCall,
   attachHttp
-} from "./bah9nbg3.js";
+} from "./npdftanb.js";
 import {
   emitWhere,
   emitOrder,

package/dist/shared/{jx2m62cs.js → xv8qj97g.js}

@@ -4,23 +4,23 @@ import {
 import {
   connectClient2,
   send3
-} from "./agsfb86s.js";
+} from "./mazpbcdj.js";
 import {
   resetSession2
-} from "./7ghwamrf.js";
+} from "./99qp9vtg.js";
 import {
   isConnectionLost
 } 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/neon-extra.ts
 async function checkout(held) {

package/dist/shared/{63f4ksbz.js → xwhdcrm4.js}

@@ -1,7 +1,7 @@
 import {
   touchFields,
   fieldSealed
-} from "./bxas03mq.js";
+} from "./9dtgn1z2.js";
 import {
   projectExpr,
   quote,

package/dist/shared/{hm5f8jby.js → yvabyg9k.js}

@@ -1,24 +1,24 @@
 import {
   open2
-} from "./35q0n9tz.js";
+} from "./dd5pmnky.js";
 import"./12z7aznj.js";
+import"./fk9vef30.js";
 import"./n442h54c.js";
 import {
   assertRoleHealth
-} from "./kj9d8maq.js";
-import"./p3xbdcvt.js";
+} from "./jpybhf98.js";
+import"./myk8fswx.js";
 import {
   errorDoc,
   openProject
-} from "./f4jy1j7x.js";
+} from "./2zdxkt7b.js";
 import {
   omitManagedObjects,
   sessionFailure,
   finishQuiet,
   assertTargetPolicy,
   selectTarget
-} from "./dpc2r7rb.js";
-import"./sjk86yrx.js";
+} from "./6nae0spm.js";
 import {
   OkmError2
 } from "./52szzakm.js";