dzql 0.10.0 → 0.12.0

package/src/postgres/auth-link.ts

@@ -0,0 +1,53 @@
+/**
+ * Link sign-in on Postgres: the `LinkStore` delta's `auth-link` keeps its links and sessions in
+ * (`@blueshed/delta/auth-link`; Workshop's docs/link-sign-in-plan.md). The tables are its own,
+ * `_auth_links` and `_auth_sessions`, beside delta's `_delta_*`: hashes, the person's id, times. A
+ * link is used in one statement, so two taps at once make one session, on one server or several.
+ *
+ *   import { linkAuth } from "@blueshed/delta/auth-link";
+ *   import { postgresLinkStore } from "dzql/auth-link";
+ *
+ *   const auth = linkAuth({ store: await postgresLinkStore(pool), personOf, people });
+ */
+import type { Pool } from "pg";
+import type { KeptLink, KeptSession, LinkStore } from "@blueshed/delta/auth-link";
+
+export { linkAuth, makeLink } from "@blueshed/delta/auth-link";
+
+/** The links and sessions in Postgres, in tables of their own, made here (once: IF NOT EXISTS). */
+export async function postgresLinkStore(pool: Pool): Promise<LinkStore> {
+  await pool.query(`CREATE TABLE IF NOT EXISTS _auth_links (hash TEXT PRIMARY KEY, person BIGINT NOT NULL, opens TEXT, expires TIMESTAMPTZ NOT NULL, used TIMESTAMPTZ)`);
+  await pool.query(`CREATE TABLE IF NOT EXISTS _auth_sessions (hash TEXT PRIMARY KEY, person BIGINT NOT NULL, expires TIMESTAMPTZ NOT NULL)`);
+  // Times as delta's store has them: ISO strings; a person's id a number (pg reads BIGINT as text)
+  const iso = (t: Date | string | null) => (t === null ? null : new Date(t).toISOString());
+  const SESSION = "SELECT person::int AS person, expires FROM _auth_sessions WHERE hash = $1";
+  return {
+    async addLink(hash, l) {
+      await pool.query("INSERT INTO _auth_links (hash, person, opens, expires) VALUES ($1, $2, $3, $4)", [hash, l.person, l.opens, l.expires]);
+    },
+    async useLink(hash, now) {
+      const { rows } = await pool.query(
+        "UPDATE _auth_links SET used = $1 WHERE hash = $2 AND used IS NULL AND expires > $1 RETURNING person::int AS person, opens",
+        [now, hash],
+      );
+      return rows[0] ?? null;
+    },
+    async link(hash): Promise<KeptLink | null> {
+      const { rows } = await pool.query("SELECT person::int AS person, opens, expires, used FROM _auth_links WHERE hash = $1", [hash]);
+      return rows[0] ? { ...rows[0], expires: iso(rows[0].expires)!, used: iso(rows[0].used) } : null;
+    },
+    async addSession(hash, s) {
+      await pool.query("INSERT INTO _auth_sessions (hash, person, expires) VALUES ($1, $2, $3)", [hash, s.person, s.expires]);
+    },
+    async session(hash): Promise<KeptSession | null> {
+      const { rows } = await pool.query(SESSION, [hash]);
+      return rows[0] ? { person: rows[0].person, expires: iso(rows[0].expires)! } : null;
+    },
+    async renewSession(hash, expires) {
+      await pool.query("UPDATE _auth_sessions SET expires = $1 WHERE hash = $2", [expires, hash]);
+    },
+    async endSession(hash) {
+      await pool.query("DELETE FROM _auth_sessions WHERE hash = $1", [hash]);
+    },
+  };
+}

package/src/postgres/cli.ts

@@ -1,8 +1,8 @@
 #!/usr/bin/env bun
 /**
- * dzql's Postgres commands, as delta's CLI had them: `dzql sql`, `dzql init`
- * and `dzql migrate` (a postgres:// URL or a PGlite directory). Run through
- * `dzql <command>` (src/cli/index.ts hands these three here).
+ * dzql's Postgres commands, as delta's CLI had them: `dzql sql`, `dzql init`,
+ * `dzql migrate` (a postgres:// URL or a PGlite directory), and `dzql link`. Run through
+ * `dzql <command>` (src/cli/index.ts hands these four here).
  */
 import { parseArgs } from "node:util";
 import { resolve, basename, join, dirname } from "node:path";
@@ -26,6 +26,8 @@ const USAGE =
     `  dzql init <dir> [--with-auth] [--upgrade]\n` +
     `  dzql migrate <database> [--app <name>] [--dir <migrations>] [--status] [--json]\n` +
     `        <database>: a PGlite directory or a postgres:// URL; --dir defaults to ./migrations\n` +
+    `  dzql link <database> <person> [--origin <url>] [--opens <path>] [--json]\n` +
+    `        a link to sign in as someone (link sign-in): the first person's, on the server\n` +
     `\n` +
     `Exit codes: 0 done, 1 an error, 2 a bad argument.\n`;
 
@@ -299,6 +301,41 @@ async function cmdMigrate(target: string | undefined, values: Record<string, unk
   if (!r.fresh && r.ran.length === 0) process.stdout.write("nothing to run\n");
 }
 
+// ---------------------------------------------------------------------------
+// dzql link
+// ---------------------------------------------------------------------------
+
+/**
+ * A link to sign in as `person` (link sign-in, `dzql/auth-link`), made in the app's Postgres: how
+ * the first person signs in, before anyone can send them one. The site is --origin, else ORIGIN,
+ * else Railway's domain. The database as `migrate` takes it. A SQLite file is delta's (`delta link`).
+ */
+async function cmdLink(target: string | undefined, person: string | undefined, values: Record<string, unknown>) {
+  if (!target || !person) usageError("link takes a <database> and a <person>: dzql link postgres://… 1", true);
+  if (!/^\d+$/.test(person)) usageError(`<person> is a person's id, a number: ${person}`);
+  const isUrl = /^postgres(ql)?:\/\//.test(target);
+  const path = resolve(process.cwd(), target);
+  if (!isUrl && (!existsSync(path) || !statSync(path).isDirectory())) usageError(`no PGlite database at ${target} (a SQLite file is delta's: bunx @blueshed/delta link)`);
+  const { makeLink, siteOrigin } = await import("@blueshed/delta/auth-link");
+  let origin: string;
+  try { origin = (values.origin as string | undefined) ?? siteOrigin(); }
+  catch (err) { usageError(`${(err as Error).message}, or pass --origin`); }
+  const { postgresLinkStore } = await import("./auth-link");
+  let pool: any;
+  if (isUrl) {
+    const { Pool } = await import("pg");
+    pool = new Pool({ connectionString: target });
+  } else {
+    const { openPglite } = await import("./pglite");
+    pool = await openPglite(path);
+  }
+  try {
+    const made = await makeLink(await postgresLinkStore(pool), Number(person), { origin, opens: values.opens as string | undefined });
+    if (json) return print(made);
+    process.stdout.write(`${made.url}\n(used once, until ${made.expires})\n`);
+  } finally { await pool.end(); }
+}
+
 // ---------------------------------------------------------------------------
 // main
 // ---------------------------------------------------------------------------
@@ -318,6 +355,8 @@ export async function main(argv: string[]) {
       dir: { type: "string" },
       app: { type: "string" },
       status: { type: "boolean", default: false },
+      origin: { type: "string" },
+      opens: { type: "string" },
       help: { type: "boolean", short: "h", default: false },
     },
     allowPositionals: true,
@@ -327,11 +366,12 @@ export async function main(argv: string[]) {
   const { values, positionals } = parsed;
   json = !!values.json;
   if (values.help) { process.stdout.write(USAGE); return; }
-  const [cmd, arg] = positionals;
+  const [cmd, arg, arg2] = positionals;
   switch (cmd) {
     case "sql":     return cmdSql(arg, values);
     case "init":    return cmdInit(arg, values);
     case "migrate": return cmdMigrate(arg, values);
+    case "link":    return cmdLink(arg, arg2, values);
     default:        usageError(cmd ? `no command ${cmd}` : "a command, please", true);
   }
 }

package/src/postgres/codegen.ts

@@ -36,6 +36,7 @@ import { compileColumns } from "../compile/columns";
 import { compileRows } from "../compile/rows";
 import { compileCascades } from "../compile/cascades";
 import { compileLedger } from "../compile/ledger";
+import { compileLookups } from "../compile/lookups";
 import { compileTold } from "../compile/told";
 
 export interface GenerateSqlOptions {
@@ -180,6 +181,6 @@ export function generateSql(
   lines.push("");
 
   // each document opened by SQL compiled for it (dzql), which docTypeFromDef calls
-  lines.push("", compileOpens(schema, docs), "", compileHolds(schema, docs), "", compileInScope(schema, docs), "", compileTold(schema, docs), "", compileHolders(schema, docs), "", compileResolve(schema, docs), "", compileRootThere(schema, docs), "", compileColumns(schema, docs), "", compileRows(schema), "", compileCascades(schema), "", compileLedger(schema, docs));
+  lines.push("", compileOpens(schema, docs), "", compileHolds(schema, docs), "", compileInScope(schema, docs), "", compileTold(schema, docs), "", compileHolders(schema, docs), "", compileResolve(schema, docs), "", compileRootThere(schema, docs), "", compileColumns(schema, docs), "", compileRows(schema), "", compileCascades(schema), "", compileLedger(schema, docs), "", compileLookups(schema, docs));
   return lines.join("\n");
 }

package/src/postgres/listener.ts

@@ -89,12 +89,15 @@ function errMsg(err: unknown): string {
  * entry that is not the cursor's next (409). And 40P01, a write that met another
  * at once and gave way to it (two adds of temporal ids in opposite orders wait
  * on each other's row locks, todo #16): nothing was written, and the same write
- * sent again goes through, or meets the rows the other made (409). Anything
- * else is the server's (500).
+ * sent again goes through, or meets the rows the other made (409). A document
+ * type that refuses with a wire code of its own (a number, 400 to 499: a
+ * read-only document's 403) is answered with it. Anything else is the
+ * server's (500).
  */
 const CODE_OF_SQLSTATE: Record<string, number> = { "22023": 400, "22P02": 400, "22007": 400, "22008": 400, "23502": 400, "25006": 403, P0002: 404, "23505": 409, "40001": 409, "40P01": 409 };
 function wireCode(err: unknown): number {
   const state = (err as { code?: unknown } | null)?.code;
+  if (typeof state === "number" && state >= 400 && state < 500) return state;
   return (typeof state === "string" && CODE_OF_SQLSTATE[state]) || 500;
 }
 
@@ -122,6 +125,15 @@ interface DocState {
 /** _delta_fetch_log (delta_fetch_ops' rows) caps each call at this many; a full page means there may be more. */
 const FETCH_PAGE = 1000;
 
+/**
+ * What a custom document hears of a log entry: each write once, as it was applied. The writer's
+ * entry carries it (`applied`) where the writer was told otherwise, and null where it was told the
+ * write as applied; each other told document's entry of the write carries none ([]). Told, a row
+ * that left a document is a remove, which is not a delete, and a row told to two documents would be
+ * heard twice (todo #44). An entry logged some other way carries null too: heard as told.
+ */
+const appliedOf = (row: any): DeltaOp[] => (row.applied ?? row.ops) as DeltaOp[];
+
 /**
  * How the listener reads a document's log. `_delta_fetch_log` (001e) gives each
  * entry with the write as applied, for custom documents (todo #44). Framework
@@ -250,7 +262,7 @@ export async function createDocListener<I = unknown>(
   // are recycled by the pool, and a stale listener would fire against this
   // closure's state (and spuriously trigger reconnect) on a future checkout.
   function detachListener(client: any) {
-    try { client.removeListener?.("notification", onNotification); } catch {}
+    try { client.removeListener?.("notification", heard); } catch {}
     if (errorHandler) {
       try { client.removeListener?.("error", errorHandler); } catch {}
     }
@@ -259,7 +271,7 @@ export async function createDocListener<I = unknown>(
   /** LISTEN on `client`, and keep this holder's lock on it. */
   async function setupListener(client: any): Promise<void> {
     await client.query("LISTEN delta_changes");
-    client.on("notification", onNotification);
+    client.on("notification", heard);
     errorHandler = (err: Error) => {
       log.error(`listener error: ${err.message}`);
       if (!destroyed) reconnect();
@@ -306,7 +318,7 @@ export async function createDocListener<I = unknown>(
       state.until = Number.MAX_SAFE_INTEGER;   // the notifications while away are gone: read to the end
       if (state.notifying) { state.pending = true; continue; }
       state.notifying = true;
-      try { await drainDoc(docName, state); }
+      try { await drainDoc(docName, state, true); }
       catch (err) { log.error(`resync ${docName}: ${errMsg(err)}`); }
       finally { state.notifying = false; }
     }
@@ -320,28 +332,38 @@ export async function createDocListener<I = unknown>(
     throw err;
   }
 
-  // Notification handler — fans out LISTEN/NOTIFY to WS subscribers, plus
-  // custom-doc cross-pollination when any predicate-based doc is registered.
+  // A document's own subscribers need only its own order, so each document drains on its own
+  // (onNotification), and none waits on another's. A custom document hears writes made through
+  // every document, so it is told them one after another, as Postgres delivers the notifications
+  // (in commit order): told from each document's drain, a slow read of one told it a later write,
+  // made through another, first.
+  let inCommitOrder: Promise<void> = Promise.resolve();
+  function heard(msg: any) {
+    void onNotification(msg);
+    if (custom.size > 0) inCommitOrder = inCommitOrder.then(() => hearCustom(msg));
+  }
+
+  /** The custom documents told the one write a notification announces: its document's entry at that version. */
+  async function hearCustom(msg: any) {
+    if (destroyed || msg.channel !== "delta_changes" || !msg.payload) return;
+    try {
+      const { doc: docName, v } = JSON.parse(msg.payload);
+      const rows = (await pool.query(fetchSql, [docName, v - 1])).rows.filter((row: any) => Number(row.version) === v);
+      if (auth && rows.length > 0) await custom.letGoWatching(rows.flatMap(appliedOf));
+      for (const row of rows) custom.tell(appliedOf(row));
+    } catch (err) {
+      log.error(`notify error (custom): ${errMsg(err)}`);
+    }
+  }
+
+  // Notification handler — fans out LISTEN/NOTIFY to the document's WS subscribers.
   async function onNotification(msg: any) {
     if (destroyed) return;
     if (msg.channel !== "delta_changes" || !msg.payload) return;
     try {
       const { doc: docName, v } = JSON.parse(msg.payload);
-      let state = tracked.get(docName);
-
-      // Even without direct subscribers, we still process notifications if any
-      // custom doc is registered — a watched collection's rows may need fan-out.
-      if (!state && custom.size === 0) return;
-      if (!state) {
-        // Initialize at v-1 so we fetch only the current notification's row.
-        // Custom docs loaded their initial state via `def.query` on open, so
-        // pre-existing ops are already reflected — replaying history would
-        // duplicate them. Same logic protects close-then-reopen.
-        state = { version: Math.max(0, v - 1), until: v, subscribers: new Set(), notifying: false, pending: false };
-        tracked.set(docName, state);
-      }
-
-      if (v <= state.version) return;
+      const state = tracked.get(docName);
+      if (!state || v <= state.version) return;
       state.until = Math.max(state.until, v);
       if (state.notifying) {
         // A fetch is already running for this doc. Coalesce instead of dropping:
@@ -364,8 +386,9 @@ export async function createDocListener<I = unknown>(
   // Drain a doc's ops to its subscribers. Loops while a full page comes back
   // (a backlog larger than the fetch's LIMIT) and re-runs if another
   // notification arrived mid-drain (the coalesced `pending` flag). Caller owns
-  // the `notifying` guard.
-  async function drainDoc(docName: string, state: DocState) {
+  // the `notifying` guard. After a reconnect (`resync`) the custom documents
+  // are told what it reads too: the notifications while away are gone.
+  async function drainDoc(docName: string, state: DocState, resync = false) {
     do {
       state.pending = false;
       let more = true;
@@ -374,11 +397,10 @@ export async function createDocListener<I = unknown>(
         // only what a notification has announced (`until`): the rest is heard with its own
         const rows = page.filter((row: any) => Number(row.version) <= state.until);
         more = page.length >= FETCH_PAGE && rows.length === page.length;
-        // Told to those who may still hear it (todo #17): the document's own
-        // subscribers, and the custom documents' that watch what it changed.
+        // Told to those who may still hear it (todo #17): the document's own subscribers
         if (auth && rows.length > 0) {
           await custom.letGo(docName, state.subscribers, ownsOf(docName));
-          await custom.letGoWatching(rows.flatMap((row: any) => (row.applied ?? row.ops) as DeltaOp[]));
+          if (resync) await custom.letGoWatching(rows.flatMap(appliedOf));
         }
         for (const row of rows) {
           if (state.subscribers.size > 0) {
@@ -390,14 +412,7 @@ export async function createDocListener<I = unknown>(
             ws.publish(docName, { doc: docName, ops: shownOps(resolveDoc(docName)?.type.def, row.ops), v: Number(row.version) });
           }
           state.version = Number(row.version);
-          // A custom document hears each write once, as it was applied: the
-          // writer's entry carries it (`applied`) where the writer was told
-          // otherwise, and null where it was told the write as applied; each
-          // other told document's entry of the write carries none ([]). Told,
-          // a row that left a document is a remove, which is not a delete, and
-          // a row told to two documents would be heard twice (todo #44). An
-          // entry logged some other way carries null too: heard as told.
-          custom.tell((row.applied ?? row.ops) as DeltaOp[]);
+          if (resync) custom.tell(appliedOf(row));
         }
       }
     } while (state.pending);

package/src/postgres/pglite.ts

@@ -137,6 +137,9 @@ export async function openPglite(dir?: string): Promise<Pool> {
   } catch {
     throw new Error("[delta/pglite] @electric-sql/pglite is not installed -- bun add @electric-sql/pglite");
   }
-  const db: PGliteish = dir ? await PGlite.create(dir) : await PGlite.create();
+  // pgcrypto, which dzql/auth-jwt hashes passwords with: PGlite has an extension only when it is
+  // given one at start (loaded when a database creates it)
+  const { pgcrypto } = await import("@electric-sql/pglite/contrib/pgcrypto");
+  const db: PGliteish = await PGlite.create(dir, { extensions: { pgcrypto } });
   return pglitePool(db);
 }

package/src/sql/001a-delta-meta.sql

@@ -30,6 +30,49 @@ ALTER TABLE _delta_docs ADD COLUMN IF NOT EXISTS implied BOOLEAN NOT NULL DEFAUL
 -- collection not named, whole. It is opened, told and written by those alone.
 ALTER TABLE _delta_docs ADD COLUMN IF NOT EXISTS held JSONB NOT NULL DEFAULT '{}';
 
+-- The framework that read the definitions at run time retired (todo #26): each
+-- document and collection is compiled by generateSql (dzql/compile). Dropped
+-- where an earlier version made them.
+DROP FUNCTION IF EXISTS _delta_collection_framework(text);
+DROP FUNCTION IF EXISTS _delta_assert_fields_framework(text, jsonb, text, jsonb);
+DROP FUNCTION IF EXISTS _delta_temporal_where(timestamptz, text);
+DROP FUNCTION IF EXISTS _delta_find_doc_framework(text);
+DROP FUNCTION IF EXISTS _delta_resolve_scope_framework(_delta_docs, text, boolean);
+DROP FUNCTION IF EXISTS _delta_row_in_scope_framework(_delta_docs, text, text, bigint);
+DROP FUNCTION IF EXISTS _delta_chain_root(text, jsonb, text);
+DROP FUNCTION IF EXISTS _delta_doc_holds_framework(_delta_docs, text, text, jsonb);
+DROP FUNCTION IF EXISTS _delta_holders_framework(text, jsonb, text, text[]);
+DROP FUNCTION IF EXISTS _delta_load_collection(text, text, bigint, timestamptz);
+DROP FUNCTION IF EXISTS _delta_load_collection_all(text, timestamptz);
+DROP FUNCTION IF EXISTS _delta_read_list(_delta_docs, text, timestamptz);
+DROP FUNCTION IF EXISTS _delta_show_doc(_delta_docs, jsonb, boolean);
+DROP FUNCTION IF EXISTS _delta_open_framework(text, boolean);
+DROP FUNCTION IF EXISTS _delta_serial_past_framework(text, bigint);
+DROP FUNCTION IF EXISTS _delta_serial_new_framework(text, bigint);
+DROP FUNCTION IF EXISTS _delta_cascade_remove_framework(text, bigint);
+DROP FUNCTION IF EXISTS _delta_cascade_rows_framework(text, bigint);
+DROP FUNCTION IF EXISTS _delta_hanging_rows_framework(text, bigint);
+DROP FUNCTION IF EXISTS _delta_told_framework(_delta_docs, text, jsonb);
+DROP FUNCTION IF EXISTS _delta_row_there_framework(text, bigint);
+DROP FUNCTION IF EXISTS _delta_held_columns(_delta_docs, text, jsonb);
+DROP FUNCTION IF EXISTS _delta_root_there_framework(_delta_docs, text, jsonb, text, bigint);
+DROP FUNCTION IF EXISTS _delta_write_columns_framework(_delta_docs, text, jsonb);
+DROP FUNCTION IF EXISTS _delta_row_lock_framework(text, text, boolean, bigint);
+DROP FUNCTION IF EXISTS _delta_row_put_framework(text, text, boolean, bigint, jsonb, timestamptz);
+DROP FUNCTION IF EXISTS _delta_next_id_framework(text, text);
+DROP FUNCTION IF EXISTS _delta_row_clear_moment_framework(text, text, bigint, timestamptz);
+DROP FUNCTION IF EXISTS _delta_row_add_framework(text, text, jsonb);
+DROP FUNCTION IF EXISTS _delta_row_read_framework(text, text, bigint);
+DROP FUNCTION IF EXISTS _delta_open_at_framework(text, timestamptz);
+DROP FUNCTION IF EXISTS _delta_same_framework(text, text, jsonb, jsonb);
+DROP FUNCTION IF EXISTS _delta_row_standing_framework(text, bigint);
+
+-- _delta_collection: a collection's definition (NULL fields: there is none).
+-- generateSql writes each collection in (compileLookups); before it is applied,
+-- there is none.
+CREATE OR REPLACE FUNCTION _delta_collection(p_key TEXT)
+RETURNS _delta_collections LANGUAGE sql STABLE AS $$ SELECT NULL::_delta_collections; $$;
+
 CREATE TABLE IF NOT EXISTS _delta_versions (
   doc_name TEXT PRIMARY KEY,
   version  BIGINT NOT NULL DEFAULT 0
@@ -135,8 +178,10 @@ $$;
 -- not have, or gives a column a value not of its type (SQLSTATE 22023 → 400).
 -- It used to be merged into the broadcast row, acked, and dropped (or cast) by
 -- jsonb_populate_record: stored otherwise than told. id, the parent key and
--- the temporal columns are the row's own.
-CREATE OR REPLACE FUNCTION _delta_assert_fields_framework(
+-- the temporal columns are the row's own. By the columns given (`p_columns`): a
+-- set the compiler did not write in (another version's, `delta.declared`; a
+-- walk's, as its entry was stored) is checked here.
+CREATE OR REPLACE FUNCTION _delta_assert_fields_declared(
   p_collection TEXT, p_columns JSONB, p_parent_fk TEXT, p_value JSONB
 ) RETURNS void LANGUAGE plpgsql IMMUTABLE AS $$
 DECLARE
@@ -178,16 +223,16 @@ BEGIN
 END;
 $$;
 
--- The checks every write asks: the framework's, until dzql's compiler
--- (`compileColumns`) replaces this with one that checks each column set it
--- compiled by its own statements, and any other by the framework's.
+-- The checks every write asks: generateSql (`compileColumns`) replaces this
+-- with one that checks each column set it compiled by its own statements, and
+-- any other by the columns given.
 CREATE OR REPLACE FUNCTION _delta_assert_fields(
   p_collection TEXT, p_columns JSONB, p_parent_fk TEXT, p_value JSONB
-) RETURNS void LANGUAGE sql IMMUTABLE AS $$ SELECT _delta_assert_fields_framework(p_collection, p_columns, p_parent_fk, p_value); $$;
+) RETURNS void LANGUAGE sql IMMUTABLE AS $$ SELECT _delta_assert_fields_declared(p_collection, p_columns, p_parent_fk, p_value); $$;
 
 -- Pick the source relation for a collection.
 --   temporal + no timestamp → current_<table> view
---   temporal + timestamp    → base <table> (caller filters with _delta_temporal_where)
+--   temporal + timestamp    → base <table> (the caller filters by its time)
 --   non-temporal            → base <table>
 CREATE OR REPLACE FUNCTION _delta_source_view(
   p_table_name TEXT, p_temporal BOOLEAN, p_at TIMESTAMPTZ DEFAULT NULL
@@ -197,15 +242,3 @@ CREATE OR REPLACE FUNCTION _delta_source_view(
     ELSE p_table_name
   END;
 $$;
-
--- Temporal WHERE fragment for embedding into format()-built dynamic SQL.
--- Inlines the timestamp as a %L literal so callers don't need extra param binding.
--- Aliases the row with `p_alias` (default `t`).
-CREATE OR REPLACE FUNCTION _delta_temporal_where(
-  p_at TIMESTAMPTZ, p_alias TEXT DEFAULT 't'
-) RETURNS text LANGUAGE sql IMMUTABLE AS $$
-  SELECT format(
-    '%s.valid_from <= %L AND (%s.valid_to IS NULL OR %s.valid_to > %L)',
-    p_alias, p_at, p_alias, p_alias, p_at
-  );
-$$;