okmodel 0.1.1 → 0.3.0

package/dist/shared/c9z5g0fm.js

@@ -0,0 +1,309 @@
+import {
+  definition,
+  rejected,
+  writeArray,
+  readArray
+} from "./tmbdywx0.js";
+import {
+  quoteLiteral
+} from "./94ez8kzh.js";
+import {
+  REFERENTIAL_ACTIONS,
+  referentialAction
+} from "./4e4c6vq2.js";
+import {
+  readClientGenerator
+} from "./rwmrejjz.js";
+
+// src/dialects/pg/column.ts
+class ColumnBuilder2 {
+  state;
+  constructor(state) {
+    this.state = state;
+  }
+  encode(value) {
+    return this.state.encode(value);
+  }
+  decode(wire) {
+    return this.state.decode(wire);
+  }
+  nullable() {
+    return rebuild(this.state, { nullable: true });
+  }
+  default(value) {
+    const clientDefault = readClientGenerator(value);
+    if (clientDefault !== undefined) {
+      return rebuild(this.state, {
+        hasDefault: true,
+        defaultSql: undefined,
+        defaultValue: undefined,
+        clientDefault,
+        generated: undefined
+      });
+    }
+    if (value === null && this.state.nullable === false) {
+      definition("A null default is only accepted on a nullable column. Call .nullable() first.");
+    }
+    if (this.state.picklist !== undefined && value !== null) {
+      const text = String(value);
+      if (!this.state.picklist.values.includes(text)) {
+        definition(`Default ${text} is not in the picklist ${this.state.picklist.values.join(", ")}.`);
+      }
+    }
+    return rebuild(this.state, {
+      hasDefault: true,
+      defaultSql: value === null ? "NULL" : sqlOf(this.state, value),
+      defaultValue: value,
+      clientDefault: undefined,
+      generated: undefined
+    });
+  }
+  defaultSql(expression) {
+    if (expression.length === 0) {
+      definition("defaultSql must be a non-empty SQL expression.");
+    }
+    return rebuild(this.state, {
+      hasDefault: true,
+      defaultSql: expression,
+      defaultValue: undefined,
+      clientDefault: undefined,
+      generated: undefined
+    });
+  }
+  primaryKey() {
+    return rebuild(this.state, {
+      primaryKey: true,
+      omitUpdate: true
+    });
+  }
+  unique(options) {
+    const marker = options?.global;
+    if (typeof marker === "string" && marker.trim().length === 0) {
+      definition("unique() global needs a reason.");
+    }
+    const named = typeof marker === "string" ? marker.trim() : undefined;
+    const globalFlag = typeof marker === "string" ? true : marker;
+    return rebuild(this.state, {
+      unique: {
+        reason: named ?? options?.reason,
+        global: globalFlag
+      }
+    });
+  }
+  picklist(values, options) {
+    if (values.length === 0) {
+      definition("A picklist must contain at least one value.");
+    }
+    const allowed = new Set;
+    for (const value of values) {
+      if (value.length === 0) {
+        definition("Picklist values must be non-empty strings.");
+      }
+      if (allowed.has(value)) {
+        definition(`Picklist value ${value} is repeated. Each value is accepted once.`);
+      }
+      allowed.add(value);
+    }
+    if (typeof this.state.defaultValue === "string" && !allowed.has(this.state.defaultValue)) {
+      definition(`Default ${this.state.defaultValue} is not in the picklist ${values.join(", ")}.`);
+    }
+    const previous = this.state.elementEncode;
+    const elementEncode = (value) => {
+      if (typeof value !== "string" || !allowed.has(value)) {
+        rejected(`Picklist rejected ${String(value)}. Accepted values: ${[...allowed].join(", ")}.`);
+      }
+      return previous(value);
+    };
+    return rebuild(this.state, {
+      picklist: { values: values.slice(), check: options?.check !== false },
+      elementEncode,
+      encode: elementEncode
+    });
+  }
+  generated(expression, options) {
+    if (expression.length === 0) {
+      definition("generated() must be a non-empty SQL expression.");
+    }
+    return rebuild(this.state, {
+      generated: { stored: options?.stored !== false, expression },
+      hasDefault: true,
+      defaultSql: undefined,
+      defaultValue: undefined,
+      clientDefault: undefined
+    });
+  }
+  guarded() {
+    return rebuild(this.state, { guarded: true });
+  }
+  hidden() {
+    return rebuild(this.state, { hidden: true });
+  }
+  sensitive() {
+    return rebuild(this.state, { sensitive: true });
+  }
+  validate(rules) {
+    const list = Array.isArray(rules) ? rules : [rules];
+    return rebuild(this.state, { validate: { rules: list } });
+  }
+  references(table, options) {
+    if (table.length === 0) {
+      definition("references() needs a table name.");
+    }
+    const onDelete = readAction(options?.onDelete, "onDelete");
+    const onUpdate = readAction(options?.onUpdate, "onUpdate");
+    const columns = readReferenceColumns(options?.columns);
+    return rebuild(this.state, {
+      references: {
+        table,
+        ...onDelete !== undefined ? { onDelete } : {},
+        ...onUpdate !== undefined ? { onUpdate } : {},
+        ...columns !== undefined ? { columns } : {}
+      }
+    });
+  }
+  renamedFrom(name) {
+    if (name.length === 0) {
+      definition("renamedFrom must be a non-empty previous column name.");
+    }
+    return rebuild(this.state, { renamedFrom: name });
+  }
+  sqlName(name) {
+    if (name.length === 0) {
+      definition("sqlName must be a non-empty SQL identifier.");
+    }
+    return rebuild(this.state, { sqlName: name });
+  }
+  comment(text) {
+    return rebuild(this.state, { comment: text });
+  }
+  array(options) {
+    if (this.state.dims !== 0) {
+      definition("array() accepts a scalar column. This column is already an array.");
+    }
+    const dims = options?.dims ?? 1;
+    if (!Number.isInteger(dims) || dims < 1 || dims > 6) {
+      definition(`Array dims ${String(dims)} must be an integer from 1 to 6.`);
+    }
+    const elementEncode = this.state.elementEncode;
+    const elementDecode = this.state.elementDecode;
+    const raw = this.state.sqlForm === "raw";
+    return rebuild(this.state, {
+      dims,
+      accepts: ["Array"],
+      encode: (value) => writeArray(value, dims, elementEncode, raw),
+      decode: (wire) => readArray(wire, dims, elementDecode)
+    });
+  }
+}
+function required(body) {
+  return openColumn({
+    nullable: false,
+    hasDefault: false,
+    generated: false,
+    guarded: false,
+    hidden: false,
+    omitWrite: false,
+    ...body
+  });
+}
+function openColumn(input) {
+  const elementEncode = input.encode;
+  const elementDecode = input.decode;
+  return new ColumnBuilder2({
+    baseType: input.baseType,
+    dims: 0,
+    nullable: input.nullable,
+    hasDefault: input.hasDefault,
+    defaultSql: input.defaultSql,
+    defaultValue: undefined,
+    clientDefault: input.clientDefault,
+    collation: input.collation,
+    idSource: input.idSource,
+    identity: input.identity,
+    generated: undefined,
+    unique: undefined,
+    picklist: undefined,
+    guarded: input.guarded,
+    hidden: input.hidden,
+    sensitive: false,
+    omitWrite: input.omitWrite,
+    omitUpdate: input.omitUpdate === true,
+    renamedFrom: undefined,
+    sqlName: undefined,
+    comment: undefined,
+    extension: input.extension,
+    typeDependency: input.typeDependency,
+    enumLabels: input.enumLabels,
+    domain: input.domain,
+    primaryKey: input.primaryKey === true,
+    typeLabel: input.typeLabel,
+    references: undefined,
+    validate: undefined,
+    sqlForm: input.sqlForm,
+    encode: input.encode,
+    decode: input.decode,
+    elementEncode,
+    elementDecode,
+    accepts: input.accepts
+  });
+}
+function formatType(baseType, dims) {
+  if (dims === 0) {
+    return baseType;
+  }
+  return baseType + "[]".repeat(dims);
+}
+function sqlOf(state, value) {
+  const encoded = state.encode(value);
+  const typed = formatType(state.baseType, state.dims);
+  if (state.sqlForm === "cast") {
+    return `${quoteLiteral(encoded)}::${typed}`;
+  }
+  if (state.sqlForm === "json") {
+    return `${quoteLiteral(encoded)}::json`;
+  }
+  if (state.sqlForm === "jsonb") {
+    return `${quoteLiteral(encoded)}::jsonb`;
+  }
+  if (state.dims > 0 || state.sqlForm === "quote") {
+    return quoteLiteral(encoded);
+  }
+  return encoded;
+}
+function readAction(action, role) {
+  if (action === undefined) {
+    return;
+  }
+  if (referentialAction(action) === undefined) {
+    definition(`references() ${role} ${action} is not a referential action. Accepted actions: ${REFERENTIAL_ACTIONS.join(", ")}.`);
+  }
+  return action;
+}
+function readReferenceColumns(columns) {
+  if (columns === undefined) {
+    return;
+  }
+  if (columns.length === 0) {
+    definition("references() columns must name at least one target column.");
+  }
+  const copy = [];
+  for (const name of columns) {
+    if (name.length === 0) {
+      definition("references() columns must be non-empty names.");
+    }
+    copy.push(name);
+  }
+  return copy;
+}
+function retarget(column, patch) {
+  return rebuild(column.state, {
+    ...patch.dropUnique === true ? { unique: undefined } : {},
+    ...patch.dropPrimary === true ? { primaryKey: false } : {},
+    ...patch.references !== undefined ? { references: patch.references } : {}
+  });
+}
+function rebuild(state, patch) {
+  return new ColumnBuilder2({ ...state, ...patch });
+}
+
+export { ColumnBuilder2, required, openColumn, formatType, retarget };

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

@@ -1,27 +1,90 @@
 import {
   open2
-} from "./dkn3y60a.js";
+} from "./xw1d69vd.js";
 import {
   catalogHash2
-} from "./y9m15dfv.js";
+} from "./t616ynfn.js";
+import"./n442h54c.js";
 import {
   loadMigrations
-} from "./jjb7yht9.js";
+} from "./g4f5kcx9.js";
+import {
+  assertCreateRole,
+  currentUser,
+  roleExists
+} from "./hcmdtwgh.js";
 import {
-  quoteIdent,
-  planMigration,
   assertTargetPolicy,
   assertDirectConnection,
   selectTarget,
   projectHead,
   loadConfig
-} from "./05w44d8g.js";
+} from "./5nmdenb6.js";
+import {
+  createdRoleName,
+  changesRole,
+  assertExtensionsAvailable,
+  planMigration
+} from "./2ssqrv66.js";
+import {
+  quoteIdent
+} from "./wekze34d.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 +163,10 @@ async function applyTarget(request) {
     await lockTarget(connection, request.target);
     locked = true;
     request.onLocked?.();
+    const session = {};
+    await prepareMigrationRole(connection, request, session);
+    await assertExtensionsAvailable(connection, request.migrations);
+    await assertUuidV7Available(connection, request.migrations);
     await connection.execute(META);
     await connection.execute(HISTORY);
     const done = await readDone(connection);
@@ -110,13 +177,17 @@ async function applyTarget(request) {
         continue;
       for (const unit of units) {
         assertUnitPolicy(request, unit);
-        await runUnit(connection, unit, request);
+        await runUnit(connection, unit, request, session);
         for (const item of unit.steps)
           done.add(`${unit.migrationId}:${String(item.index)}`);
       }
       applied.push(migration.id);
     }
-    return { target: request.target, applied };
+    return {
+      target: request.target,
+      applied,
+      ...session.setRole !== undefined ? { setRole: session.setRole } : {}
+    };
   } finally {
     if (locked)
       await connection.execute("select pg_advisory_unlock(hashtext($1))", [
@@ -142,7 +213,8 @@ nothing to apply
     allowPooler: flags.allowPooler || config.allowPooler === true,
     ...flags.lockTimeoutMs !== undefined ? { lockTimeoutMs: flags.lockTimeoutMs } : config.timeouts?.lock !== undefined ? { lockTimeoutMs: config.timeouts.lock } : {},
     ...flags.statementTimeoutMs !== undefined ? { statementTimeoutMs: flags.statementTimeoutMs } : config.timeouts?.statement !== undefined ? { statementTimeoutMs: config.timeouts.statement } : {},
-    migrations
+    migrations,
+    ...config.roles !== undefined ? { migrationRole: config.roles.migration } : {}
   });
   return formatReport(report);
 }
@@ -173,17 +245,20 @@ no changes
         catalogHash: catalogHash2(head.catalog),
         steps: plan.steps
       }
-    ]
+    ],
+    ...config.roles !== undefined ? { migrationRole: config.roles.migration } : {}
   });
   return formatReport(report);
 }
 function formatReport(report) {
+  const role = report.setRole !== undefined ? `set role ${report.setRole}
+` : "";
   if (report.applied.length === 0)
     return `target ${report.target}
-nothing to apply
+${role}nothing to apply
 `;
   return `target ${report.target}
-${report.applied.map((id) => `applied ${id}`).join(`
+${role}${report.applied.map((id) => `applied ${id}`).join(`
 `)}
 `;
 }
@@ -237,7 +312,31 @@ async function readDone(connection) {
   }
   return done;
 }
-async function runUnit(connection, unit, request) {
+async function prepareMigrationRole(connection, request, session) {
+  const role = request.migrationRole;
+  const changes = request.migrations.some((migration) => migration.steps.some((step) => changesRole(step.sql)));
+  if (role === undefined) {
+    if (changes)
+      await assertCreateRole(connection, await currentUser(connection));
+    return;
+  }
+  const current = await currentUser(connection);
+  const exists = await roleExists(connection, role);
+  if (changes)
+    await assertCreateRole(connection, exists && current !== role ? role : current);
+  if (exists && current !== role)
+    await assumeRole(connection, role, session);
+}
+async function grantSchema(connection, schema, role) {
+  await connection.execute(`grant usage, create on schema ${quoteIdent(schema)} to ${quoteIdent(role)}`);
+}
+async function assumeRole(connection, role, session) {
+  if (session.setRole === role)
+    return;
+  await connection.execute(`set role ${quoteIdent(role)}`);
+  session.setRole = role;
+}
+async function runUnit(connection, unit, request, session) {
   const retries = request.retries ?? DEFAULT_RETRIES;
   for (let attempt = 0;attempt <= retries; attempt += 1) {
     let began = false;
@@ -250,7 +349,17 @@ async function runUnit(connection, unit, request) {
       for (const item of unit.steps) {
         current = item.index;
         await rebuildInvalidIndex(connection, item.step.sql);
-        await connection.execute(item.step.sql);
+        const created = createdRoleName(item.step.sql);
+        const existed = created !== undefined && await roleExists(connection, created);
+        if (created === undefined || !existed)
+          await connection.execute(item.step.sql);
+        if (created !== undefined && created === request.migrationRole) {
+          if (!existed) {
+            await grantSchema(connection, request.schema ?? "public", created);
+            await connection.execute(`grant select, insert, update on okm_meta, okm_history to ${quoteIdent(created)}`);
+          }
+          await assumeRole(connection, created, session);
+        }
         if (!unit.transactional) {
           await connection.execute("begin");
           began = true;

package/dist/shared/dyj86cmj.js

@@ -0,0 +1,69 @@
+import {
+  encodeText,
+  decodeText
+} from "./4m9fn52z.js";
+import {
+  required,
+  openColumn
+} from "./c9z5g0fm.js";
+import {
+  definition,
+  rejected
+} from "./tmbdywx0.js";
+import {
+  readClientGenerator
+} from "./rwmrejjz.js";
+
+// src/dialects/pg/keys.ts
+function id2(options) {
+  const chosen = options?.default;
+  const client = typeof chosen === "function" ? readClientGenerator(chosen) : undefined;
+  const okid = client?.name === "okid";
+  const supplied = chosen === "none";
+  if (client === undefined && chosen !== undefined && chosen !== "uuidv7" && chosen !== "uuidv4" && chosen !== "none") {
+    definition(`id() default ${String(chosen)} must be uuidv7, uuidv4, none, or a client generator.`);
+  }
+  return openColumn({
+    baseType: okid ? "text" : "uuid",
+    nullable: false,
+    hasDefault: client !== undefined || !supplied,
+    generated: false,
+    guarded: client !== undefined || !supplied,
+    hidden: false,
+    omitWrite: client !== undefined || !supplied,
+    omitUpdate: true,
+    ...client !== undefined ? { clientDefault: client } : {},
+    ...okid ? { collation: "C" } : {},
+    idSource: chosen === undefined ? "implicit" : "column",
+    ...client === undefined && !supplied ? { defaultSql: chosen === "uuidv4" ? "gen_random_uuid()" : "uuidv7()" } : {},
+    primaryKey: true,
+    encode: okid ? encodeText : encodeUuid,
+    decode: okid ? decodeText : decodeUuid,
+    sqlForm: "quote"
+  });
+}
+function uuid2() {
+  return required({
+    baseType: "uuid",
+    encode: encodeUuid,
+    decode: decodeUuid,
+    sqlForm: "quote"
+  });
+}
+function encodeUuid(value) {
+  const text = value.toLowerCase();
+  if (!uuidText().test(text)) {
+    rejected(`uuid ${value} must be 8-4-4-4-12 hexadecimal digits, for example 01890c5a-8f0e-7c3a-9b2d-6e4f1a0b9c8d.`);
+  }
+  return text;
+}
+function decodeUuid(wire) {
+  return encodeUuid(wire);
+}
+function uuidText() {
+  uuidPattern ??= /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+  return uuidPattern;
+}
+var uuidPattern;
+
+export { id2, uuid2, encodeUuid, decodeUuid };