@intentius/chant-lexicon-sql 0.124.14 → 0.124.15

package/src/change-set.ts

@@ -0,0 +1,354 @@
+/**
+ * SQL plans as change-set parts (#3767, the document is #3181).
+ *
+ * The sql lexicon's declarative plans reach the change set through `chant
+ * lifecycle plan`. Two kinds of SQL plan do not, and this module is their
+ * adapter:
+ *
+ * - a versioned plan: the migrations a product (SQL Yodeler) would apply to
+ *   an environment, each a list of steps in the shape `diffStatements`
+ *   writes (`./core/statements.ts`). {@link sqlVersionedPlanPart}.
+ * - the plan step of the lexicon's own migration Ops, `ClickHouseRebuildOp`
+ *   and `PostgresMigrationOp`. {@link clickhouseRebuildPart} and
+ *   {@link postgresMigrationPart}.
+ *
+ * Each returns a part with planner `sql`, so it composes with every other
+ * member's in `composeChangeSet`, and a gate that binds the document gets its
+ * Cedar `context.plan` (#3182). A part written to a file as JSON reads back
+ * through core's `readChangeSetPart` with `planner: "sql"`.
+ *
+ * ## Entries
+ *
+ * One entry per object a plan touches, at the object's server name (`db.name`
+ * or `schema.name`), however many steps or migrations touch it. The action
+ * and disruption come from the change classes the steps carry, as the
+ * dialects' `CHANGE_CLASSES` and `PG_CHANGE_CLASSES` price them:
+ *
+ * - a `drop` class is a `delete` (`destroy`); a `create` class a `create`;
+ * - a `rebuild` or `expand` class, or a step a migration Op makes, is a
+ *   `replace` (`replace`): the object, or a column of it, is built again;
+ * - anything else is an `update`, its disruption the worst class's
+ *   (`metadata` in-place; `validate`, `concurrently` and `rewrite` rolling).
+ *   A step marked destructive (a column drop) makes it `destroy`. A class
+ *   neither dialect knows makes it `unknown`.
+ *
+ * A step may name its `action` itself, which wins over its classes.
+ *
+ * ## The import graph
+ *
+ * Like `@intentius/chant/change-set`, this module bundles small for a tool
+ * that runs it in CI with no TypeScript toolchain: it imports chant's plan
+ * hashing code and types only. `change-set.test.ts` holds that.
+ */
+
+import { computePlanDigest } from "@intentius/chant/lifecycle/plan-digest";
+import type {
+  ChangeSetAction,
+  ChangeSetAttribute,
+  ChangeSetDisruption,
+  ChangeSetEntry,
+  ChangeSetHole,
+  ChangeSetPart,
+} from "@intentius/chant/change-set";
+import type { MigrationStep, StatementChange } from "./core/statements";
+
+/** The lexicon a SQL part's member and entries name. */
+export const SQL_CHANGE_SET_LEXICON = "sql";
+
+/**
+ * What each change class costs, both dialects together. The same values as
+ * `CHANGE_CLASSES.disruption` (ClickHouse) and `PG_CHANGE_CLASSES.disruption`
+ * (Postgres), copied so the rule tables stay out of the bundle; the test
+ * holds the two together.
+ */
+export const SQL_CLASS_DISRUPTION: Readonly<Record<string, ChangeSetDisruption>> = {
+  create: "in-place",
+  metadata: "in-place",
+  validate: "rolling",
+  concurrently: "rolling",
+  rewrite: "rolling",
+  rebuild: "replace",
+  expand: "replace",
+  drop: "destroy",
+};
+
+/**
+ * One step of a versioned plan: a `MigrationStep` as `diffStatements` or
+ * `chant sql diff --statements --json` writes it, with what a product knows
+ * besides. Only `name` and `type` (from `StepObject`) and `kind` are needed.
+ */
+export type SqlPlanStep = MigrationStep & {
+  /** Already applied by an earlier, partial run: it proposes nothing. */
+  done?: boolean;
+  /** The action, when the product knows it better than the classes say. */
+  action?: ChangeSetAction;
+  /** A statement's classified changes, when the product has them; they become the entry's attributes. */
+  changes?: StatementChange[];
+};
+
+/** A migration of a versioned plan. A step may come wrapped as `{ step, done }`, as SQL Yodeler's plan view holds it. */
+export interface SqlPlanMigration {
+  id: string;
+  steps: ReadonlyArray<SqlPlanStep | { step: SqlPlanStep; done?: boolean }>;
+}
+
+/**
+ * A versioned plan, in the shape a product fills: the migrations it would
+ * apply to one environment, in order. SQL Yodeler's `VersionedPlan` (`yodel
+ * plan <env> --json`) is one as it stands: `pending` for `migrations`, its
+ * `refusal` and `digest`.
+ */
+export interface SqlVersionedPlan {
+  dialect: string;
+  /** The environment it plans into: the member's and every entry's `scope`. */
+  environment?: string;
+  /** The migrations to apply, in order. */
+  migrations?: ReadonlyArray<SqlPlanMigration>;
+  /** SQL Yodeler's name for `migrations`, read when `migrations` is absent. */
+  pending?: ReadonlyArray<SqlPlanMigration>;
+  /**
+   * The digest the product's own gate binds. When given, it is the member's
+   * `planDigest`, so a gate on the member alone and the product's approval
+   * bind one value. Absent, the adapter takes `computePlanDigest(
+   * "sql-versioned-plan", …)` over the dialect, environment and steps.
+   */
+  digest?: string;
+  /** Why the product would refuse to apply: the member is `failed`. */
+  refusal?: string | { message: string };
+  /** What the product could not read; the plan says nothing about it. */
+  holes?: ChangeSetHole[];
+}
+
+export interface SqlVersionedPlanPartInput {
+  member: string;
+  plan: SqlVersionedPlan;
+  /** Default `"sql"`. */
+  lexicon?: string;
+}
+
+const RANK: Record<ChangeSetDisruption, number> = { "in-place": 0, rolling: 1, unknown: 2, replace: 3, destroy: 4 };
+const worst = (a: ChangeSetDisruption | undefined, b: ChangeSetDisruption): ChangeSetDisruption => (a === undefined || RANK[b] > RANK[a] ? b : a);
+const ACTION_ORDER: ChangeSetAction[] = ["delete", "replace", "create", "update", "forget", "read", "no-op"];
+
+/** What the adapter gathers for one object across every step that touches it. */
+interface ObjectChanges {
+  address: string;
+  type: string;
+  classes: string[];
+  actions: ChangeSetAction[];
+  destructive: boolean;
+  /** A step a migration Op makes. */
+  ops: string[];
+  manual: string[];
+  sql: string[];
+  fields: Map<string, StatementChange>;
+}
+
+const unwrap = (s: SqlPlanStep | { step: SqlPlanStep; done?: boolean }): SqlPlanStep =>
+  "step" in s && s.step && typeof s.step === "object" ? { ...s.step, ...(s.done ? { done: true } : {}) } : (s as SqlPlanStep);
+
+function gather(steps: Iterable<SqlPlanStep>): ObjectChanges[] {
+  const byAddress = new Map<string, ObjectChanges>();
+  for (const step of steps) {
+    if (step.done) continue;
+    let o = byAddress.get(step.name);
+    if (!o) {
+      o = { address: step.name, type: step.type, classes: [], actions: [], destructive: false, ops: [], manual: [], sql: [], fields: new Map() };
+      byAddress.set(step.name, o);
+    }
+    if (step.action) o.actions.push(step.action);
+    const changes: readonly StatementChange[] = step.changes ?? [];
+    if (step.kind === "statement") {
+      o.classes.push(step.class);
+      o.sql.push(step.sql);
+      if (step.destructive) o.destructive = true;
+    } else if (step.kind === "op") {
+      o.ops.push(step.op);
+    } else {
+      o.manual.push(step.detail);
+    }
+    for (const c of changes) {
+      o.classes.push(c.class);
+      if (c.destructive) o.destructive = true;
+      const had = o.fields.get(c.field);
+      // The first step's before, the last step's after.
+      o.fields.set(c.field, had ? { ...c, ...(had.before !== undefined ? { before: had.before } : {}) } : c);
+    }
+  }
+  return [...byAddress.values()];
+}
+
+function attributesOf(o: ObjectChanges): ChangeSetAttribute[] {
+  const attributes: ChangeSetAttribute[] = [...o.fields.values()]
+    .sort((a, b) => (a.field < b.field ? -1 : a.field > b.field ? 1 : 0))
+    .map((c) => ({
+      path: c.field,
+      ...(c.before !== undefined ? { before: c.before } : {}),
+      ...(c.after !== undefined ? { after: c.after } : {}),
+      ...(SQL_CLASS_DISRUPTION[c.class] === "replace" ? { forcesReplacement: true as const } : {}),
+    }));
+  if (o.sql.length > 0) attributes.push({ path: "sql", after: o.sql });
+  if (o.ops.length > 0) attributes.push({ path: "op", after: [...new Set(o.ops)] });
+  if (o.manual.length > 0) attributes.push({ path: "manual", after: o.manual });
+  return attributes;
+}
+
+/** The action and disruption of one object's changes, as the module's header says. */
+export function sqlChangeAction(o: Pick<ObjectChanges, "classes" | "actions" | "destructive" | "ops">): { action: ChangeSetAction; disruption?: ChangeSetDisruption } {
+  let disruption: ChangeSetDisruption | undefined;
+  for (const c of o.classes) disruption = worst(disruption, SQL_CLASS_DISRUPTION[c] ?? "unknown");
+  if (o.ops.length > 0) disruption = worst(disruption, "replace");
+  if (o.destructive) disruption = worst(disruption, "destroy");
+  let action: ChangeSetAction;
+  if (o.actions.length > 0) action = ACTION_ORDER.find((a) => o.actions.includes(a))!;
+  else if (o.classes.includes("drop")) action = "delete";
+  else if (o.classes.includes("create")) action = "create";
+  else if (o.ops.length > 0 || o.classes.some((c) => SQL_CLASS_DISRUPTION[c] === "replace")) action = "replace";
+  else action = "update";
+  switch (action) {
+    case "create":
+    case "read":
+    case "no-op":
+    case "forget":
+      return { action };
+    case "delete":
+      return { action, disruption: "destroy" };
+    case "replace":
+      return { action, disruption: worst(disruption, "replace") };
+    default:
+      return { action, disruption: disruption ?? "unknown" };
+  }
+}
+
+function entriesOf(member: string, lexicon: string, scope: string | undefined, objects: ObjectChanges[]): ChangeSetEntry[] {
+  return objects.map((o) => ({
+    member,
+    lexicon,
+    planner: "sql" as const,
+    address: o.address,
+    type: o.type,
+    ...sqlChangeAction(o),
+    ...(scope !== undefined ? { scope } : {}),
+    attributes: attributesOf(o),
+  }));
+}
+
+/**
+ * A versioned plan's part ({@link SqlVersionedPlan}): one entry per object
+ * its pending steps touch, `scope` the environment. A refusal makes the
+ * member `failed` with no plan digest; its entries stay, for a reader.
+ */
+export function sqlVersionedPlanPart(input: SqlVersionedPlanPartInput): ChangeSetPart {
+  const { plan } = input;
+  const lexicon = input.lexicon ?? SQL_CHANGE_SET_LEXICON;
+  const migrations = (plan.migrations ?? plan.pending ?? []).map((m) => ({ id: m.id, steps: m.steps.map(unwrap) }));
+  const objects = gather(migrations.flatMap((m) => m.steps));
+  const refusal = plan.refusal === undefined ? undefined : typeof plan.refusal === "string" ? plan.refusal : plan.refusal.message;
+  const planDigest =
+    refusal !== undefined
+      ? null
+      : (plan.digest ??
+        computePlanDigest("sql-versioned-plan", {
+          dialect: plan.dialect,
+          environment: plan.environment ?? null,
+          migrations: migrations.map((m) => ({ id: m.id, steps: m.steps.filter((s) => !s.done) })),
+        }));
+  return {
+    member: {
+      member: input.member,
+      lexicon,
+      planner: "sql",
+      ...(plan.environment !== undefined ? { scope: plan.environment } : {}),
+      status: refusal !== undefined ? "failed" : "planned",
+      ...(refusal !== undefined ? { error: refusal } : {}),
+      planDigest,
+      holes: plan.holes ?? [],
+    },
+    entries: entriesOf(input.member, lexicon, plan.environment, objects),
+  };
+}
+
+// ── the migration Ops' plan steps ─────────────────────────────────────────────
+
+/**
+ * What a migration Op's plan step returns, as far as a part needs it:
+ * `clickhouseRebuildPlan`'s `RebuildPlanResult` and `postgresMigrationPlan`'s
+ * `MigrationPlanResult` (`./op/activities/`).
+ */
+export interface SqlOpPlan {
+  state: string;
+  /** ClickHouse: the table, `database.name`. */
+  table?: string;
+  /** Postgres: `schema.table.column`. */
+  migration?: string;
+  /** The plan's digest; present while there is something to do. */
+  planDigest?: string;
+  /** Each classified change, as `<rule> <field>: <before> -> <after>`. */
+  changes: string[];
+  /** The same changes, structured. Each becomes an attribute; without them, only the field is read from `changes`. */
+  classified?: StatementChange[];
+}
+
+export interface SqlOpPlanPartInput {
+  member: string;
+  plan: SqlOpPlan;
+  /** The environment the Op runs against: the member's and the entry's `scope`. */
+  environment?: string;
+  /** Default `"sql"`. */
+  lexicon?: string;
+}
+
+/** A change as a plain string, read back as far as its rule and field go. */
+function changeOf(line: string): StatementChange {
+  const m = /^(\S+)\s+([^\s:]+)/.exec(line);
+  return { rule: m?.[1] ?? line, class: "unknown", field: m?.[2] ?? line };
+}
+
+function opPart(input: SqlOpPlanPartInput, op: "ClickHouseRebuildOp" | "PostgresMigrationOp", active: string, address: string, type: string): ChangeSetPart {
+  const { plan } = input;
+  const lexicon = input.lexicon ?? SQL_CHANGE_SET_LEXICON;
+  const running = plan.state === active;
+  const changes = plan.classified ?? plan.changes.map(changeOf);
+  const objects = running
+    ? gather([{ kind: "op", object: address, type, name: address, op, importPath: "", options: {}, declaration: "", changes, detail: "" }])
+    : [];
+  // Swapped or done: the Op has nothing left to change in the schema; the digest says which.
+  const planDigest = running && plan.planDigest ? plan.planDigest : computePlanDigest("sql-op-plan", { op, address, state: plan.state, planDigest: plan.planDigest ?? null });
+  return {
+    member: {
+      member: input.member,
+      lexicon,
+      planner: "sql",
+      ...(input.environment !== undefined ? { scope: input.environment } : {}),
+      status: "planned",
+      planDigest,
+      holes: [],
+    },
+    entries: entriesOf(input.member, lexicon, input.environment, objects),
+  };
+}
+
+/**
+ * The part of a `ClickHouseRebuildOp`'s plan step: while the state is
+ * `rebuild`, one `replace` of the table, its plan digest the step's (the
+ * value before the verification, not the swap gate's). `swapped` and `done`
+ * propose nothing.
+ */
+export function clickhouseRebuildPart(input: SqlOpPlanPartInput): ChangeSetPart {
+  const table = input.plan.table;
+  if (!table) throw new Error("clickhouseRebuildPart: the plan names no table");
+  return opPart(input, "ClickHouseRebuildOp", "rebuild", table, "ClickHouse::Table");
+}
+
+/**
+ * The part of a `PostgresMigrationOp`'s plan step: while the state is
+ * `migrate`, one `replace` of the table (`schema.table`) whose column it
+ * expands and contracts, its plan digest the step's. `switched` and `done`
+ * propose nothing.
+ */
+export function postgresMigrationPart(input: SqlOpPlanPartInput): ChangeSetPart {
+  const migration = input.plan.migration;
+  if (!migration) throw new Error("postgresMigrationPart: the plan names no migration");
+  const table = migration.split(".").slice(0, -1).join(".") || migration;
+  return opPart(input, "PostgresMigrationOp", "migrate", table, "Postgres::Table");
+}

package/src/composites/audit-log-table.ts

@@ -13,6 +13,8 @@
 
 import { Composite } from "@intentius/chant/composite";
 import { index, table, type PostgresIndex, type PostgresSchema, type PostgresTable } from "../postgres/entities";
+import type { PostgresMemberName } from "../core/typed";
+import type { Instance, TypedComposite } from "./typed";
 
 export interface AuditLogTableProps {
   /** The table's name, unqualified. The default partition is `<name>_default`. */
@@ -25,14 +27,19 @@ export interface AuditLogTableProps {
   actor?: string;
 }
 
-export type AuditLogTableMembers = {
-  table: PostgresTable;
-  defaultPartition: PostgresTable;
+/** `Table` and `Default` are the table's and its default partition's qualified names, when the call's props give them (chant#3787). */
+export type AuditLogTableMembers<Table extends string = string, Default extends string = string> = {
+  table: PostgresTable<Table>;
+  defaultPartition: PostgresTable<Default>;
   actorIndex: PostgresIndex;
 };
 
+type AuditLogTableCall = <const N extends string, const S extends PostgresSchema | string = "public">(
+  props: AuditLogTableProps & { name: N; schema?: S },
+) => Instance<AuditLogTableMembers<PostgresMemberName<S, N>, PostgresMemberName<S, N, "_default">>>;
+
 /** An append-only audit log partitioned by month on its timestamp, with a default partition and an index by actor. */
-export const AuditLogTable = Composite<AuditLogTableProps, AuditLogTableMembers>((props) => {
+export const AuditLogTable = Composite<AuditLogTableProps, AuditLogTableMembers, TypedComposite<AuditLogTableProps, AuditLogTableMembers, AuditLogTableCall>>((props) => {
   const schema = props.schema ?? "public";
   const ts = props.timestamp ?? "occurred_at";
   const actor = props.actor ?? "actor";

package/src/composites/cdc-mirror.ts

@@ -11,6 +11,8 @@
 
 import { Composite } from "@intentius/chant/composite";
 import { table, view, type ClickHouseTable, type ClickHouseView } from "../clickhouse/entities";
+import type { ClickHouseMemberName } from "../core/typed";
+import type { Instance, TypedComposite } from "./typed";
 
 export interface CdcMirrorProps {
   /** The mirror table's name. The view of live rows is `<name>_current`. */
@@ -27,13 +29,18 @@ export interface CdcMirrorProps {
   partitionBy?: string;
 }
 
-export type CdcMirrorMembers = {
-  table: ClickHouseTable;
-  current: ClickHouseView;
+/** `Table` and `Current` are the mirror's and its view's names, when the call's props give them (chant#3787). */
+export type CdcMirrorMembers<Table extends string = string, Current extends string = string> = {
+  table: ClickHouseTable<Table>;
+  current: ClickHouseView<Current>;
 };
 
+type CdcMirrorCall = <const N extends string>(
+  props: CdcMirrorProps & { name: N },
+) => Instance<CdcMirrorMembers<ClickHouseMemberName<N>, ClickHouseMemberName<N, "_current">>>;
+
 /** A ReplacingMergeTree mirror of a CDC-fed source table, with a view of the rows not deleted. */
-export const CdcMirror = Composite<CdcMirrorProps, CdcMirrorMembers>((props) => {
+export const CdcMirror = Composite<CdcMirrorProps, CdcMirrorMembers, TypedComposite<CdcMirrorProps, CdcMirrorMembers, CdcMirrorCall>>((props) => {
   const version = props.version ?? "_version";
   const deleted = props.deleted ?? "_is_deleted";
   const mirror = table`

package/src/composites/events-table.ts

@@ -10,6 +10,8 @@
 
 import { Composite } from "@intentius/chant/composite";
 import { table, type ClickHouseTable } from "../clickhouse/entities";
+import type { ClickHouseMemberName } from "../core/typed";
+import type { Instance, TypedComposite } from "./typed";
 
 export interface EventsTableProps {
   /** The table's name, `name` or `database.name`. */
@@ -28,12 +30,15 @@ export interface EventsTableProps {
   partitionBy?: string;
 }
 
-export type EventsTableMembers = {
-  table: ClickHouseTable;
+/** `Table` is the table's name, when the call's props give it (chant#3787). */
+export type EventsTableMembers<Table extends string = string> = {
+  table: ClickHouseTable<Table>;
 };
 
+type EventsTableCall = <const N extends string>(props: EventsTableProps & { name: N }) => Instance<EventsTableMembers<ClickHouseMemberName<N>>>;
+
 /** An append-only MergeTree events table, partitioned by its timestamp and expired by TTL. */
-export const EventsTable = Composite<EventsTableProps, EventsTableMembers>((props) => {
+export const EventsTable = Composite<EventsTableProps, EventsTableMembers, TypedComposite<EventsTableProps, EventsTableMembers, EventsTableCall>>((props) => {
   const ts = props.timestamp ?? "ts";
   const events = table`
     CREATE TABLE ${props.name} (

package/src/composites/join-table.ts

@@ -10,6 +10,8 @@
 
 import { Composite } from "@intentius/chant/composite";
 import { index, table, type PostgresIndex, type PostgresSchema, type PostgresTable } from "../postgres/entities";
+import type { PostgresMemberName } from "../core/typed";
+import type { Instance, TypedComposite } from "./typed";
 
 export interface JoinTableProps {
   /** The table's name, unqualified. The reverse index is `<name>_reverse_idx`. */
@@ -36,13 +38,18 @@ export interface JoinTableProps {
   onDelete?: string;
 }
 
-export type JoinTableMembers = {
-  table: PostgresTable;
+/** `Table` is the join table's qualified name, when the call's props give it (chant#3787). */
+export type JoinTableMembers<Table extends string = string> = {
+  table: PostgresTable<Table>;
   reverseIndex: PostgresIndex;
 };
 
+type JoinTableCall = <const N extends string, const S extends PostgresSchema | string = "public">(
+  props: JoinTableProps & { name: N; schema?: S },
+) => Instance<JoinTableMembers<PostgresMemberName<S, N>>>;
+
 /** The table of a many-to-many relation: two foreign keys, a composite primary key and the reverse index. */
-export const JoinTable = Composite<JoinTableProps, JoinTableMembers>((props) => {
+export const JoinTable = Composite<JoinTableProps, JoinTableMembers, TypedComposite<JoinTableProps, JoinTableMembers, JoinTableCall>>((props) => {
   const schema = props.schema ?? "public";
   const links = table`
     CREATE TABLE ${schema}.${props.name} (

package/src/composites/refreshed-view.ts

@@ -11,6 +11,8 @@
 
 import { Composite } from "@intentius/chant/composite";
 import { index, view, type PostgresIndex, type PostgresRelation, type PostgresSchema, type PostgresView } from "../postgres/entities";
+import type { PostgresMemberName } from "../core/typed";
+import type { Instance, TypedComposite } from "./typed";
 
 export interface RefreshedViewProps {
   /** The view's name, unqualified. The index is `<name>_key`. */
@@ -27,13 +29,18 @@ export interface RefreshedViewProps {
   uniqueOn?: string;
 }
 
-export type RefreshedViewMembers = {
-  view: PostgresView;
+/** `View` is the materialized view's qualified name, when the call's props give it (chant#3787). */
+export type RefreshedViewMembers<View extends string = string> = {
+  view: PostgresView<View>;
   uniqueIndex: PostgresIndex;
 };
 
+type RefreshedViewCall = <const N extends string, const S extends PostgresSchema | string = "public">(
+  props: RefreshedViewProps & { name: N; schema?: S },
+) => Instance<RefreshedViewMembers<PostgresMemberName<S, N>>>;
+
 /** A materialized view over a source, with the unique index that allows REFRESH ... CONCURRENTLY. */
-export const RefreshedView = Composite<RefreshedViewProps, RefreshedViewMembers>((props) => {
+export const RefreshedView = Composite<RefreshedViewProps, RefreshedViewMembers, TypedComposite<RefreshedViewProps, RefreshedViewMembers, RefreshedViewCall>>((props) => {
   const schema = props.schema ?? "public";
   const summary = view`
     CREATE MATERIALIZED VIEW ${schema}.${props.name} AS

package/src/composites/replacing-table.ts

@@ -14,6 +14,8 @@
 
 import { Composite } from "@intentius/chant/composite";
 import { table, type ClickHouseTable } from "../clickhouse/entities";
+import type { ClickHouseMemberName } from "../core/typed";
+import type { Instance, TypedComposite } from "./typed";
 
 export interface ReplacingTableProps {
   /** The table's name, `name` or `database.name`. */
@@ -30,12 +32,15 @@ export interface ReplacingTableProps {
   partitionBy?: string;
 }
 
-export type ReplacingTableMembers = {
-  table: ClickHouseTable;
+/** `Table` is the table's name, when the call's props give it (chant#3787). */
+export type ReplacingTableMembers<Table extends string = string> = {
+  table: ClickHouseTable<Table>;
 };
 
+type ReplacingTableCall = <const N extends string>(props: ReplacingTableProps & { name: N }) => Instance<ReplacingTableMembers<ClickHouseMemberName<N>>>;
+
 /** A ReplacingMergeTree table that keeps the highest version of each row, with its version column. */
-export const ReplacingTable = Composite<ReplacingTableProps, ReplacingTableMembers>((props) => {
+export const ReplacingTable = Composite<ReplacingTableProps, ReplacingTableMembers, TypedComposite<ReplacingTableProps, ReplacingTableMembers, ReplacingTableCall>>((props) => {
   const version = props.version ?? "version";
   const replacing = table`
     CREATE TABLE ${props.name} (

package/src/composites/rollup-view.ts

@@ -14,6 +14,8 @@
 
 import { Composite } from "@intentius/chant/composite";
 import { table, view, type ClickHouseRelation, type ClickHouseTable, type ClickHouseView } from "../clickhouse/entities";
+import type { ClickHouseMemberName } from "../core/typed";
+import type { Instance, TypedComposite } from "./typed";
 
 export interface RollupViewProps {
   /** The target table's name. The view is `<name>_mv`. */
@@ -34,13 +36,18 @@ export interface RollupViewProps {
   partitionBy?: string;
 }
 
-export type RollupViewMembers = {
-  table: ClickHouseTable;
-  view: ClickHouseView;
+/** `Table` and `View` are the target table's and the view's names, when the call's props give them (chant#3787). */
+export type RollupViewMembers<Table extends string = string, View extends string = string> = {
+  table: ClickHouseTable<Table>;
+  view: ClickHouseView<View>;
 };
 
+type RollupViewCall = <const N extends string>(
+  props: RollupViewProps & { name: N },
+) => Instance<RollupViewMembers<ClickHouseMemberName<N>, ClickHouseMemberName<N, "_mv">>>;
+
 /** A materialized view that rolls a source table up into a target table it declares beside it. */
-export const RollupView = Composite<RollupViewProps, RollupViewMembers>((props) => {
+export const RollupView = Composite<RollupViewProps, RollupViewMembers, TypedComposite<RollupViewProps, RollupViewMembers, RollupViewCall>>((props) => {
   const target = table`
     CREATE TABLE ${props.name} (${props.columns})
     ENGINE = ${props.engine ?? "SummingMergeTree"}

package/src/composites/sharded-table.ts

@@ -14,6 +14,8 @@
 
 import { Composite } from "@intentius/chant/composite";
 import { table, type ClickHouseTable } from "../clickhouse/entities";
+import type { ClickHouseMemberName } from "../core/typed";
+import type { Instance, TypedComposite } from "./typed";
 
 export interface ShardedTableProps {
   /** The Distributed table's name, unqualified. The local table is `<name>_local`. */
@@ -30,13 +32,16 @@ export interface ShardedTableProps {
   partitionBy?: string;
 }
 
-export type ShardedTableMembers = {
-  local: ClickHouseTable;
-  distributed: ClickHouseTable;
+/** `Local` and `Distributed` are the two tables' names, when the call's props give them (chant#3787). */
+export type ShardedTableMembers<Local extends string = string, Distributed extends string = string> = {
+  local: ClickHouseTable<Local>;
+  distributed: ClickHouseTable<Distributed>;
 };
 
+type ShardedTableCall = <const N extends string>(props: ShardedTableProps & { name: N }) => Instance<ShardedTableMembers<ClickHouseMemberName<N, "_local">, ClickHouseMemberName<N>>>;
+
 /** A ReplicatedMergeTree table on every node of a cluster and the Distributed table over it. */
-export const ShardedTable = Composite<ShardedTableProps, ShardedTableMembers>((props) => {
+export const ShardedTable = Composite<ShardedTableProps, ShardedTableMembers, TypedComposite<ShardedTableProps, ShardedTableMembers, ShardedTableCall>>((props) => {
   const local = table`
     CREATE TABLE ${`${props.name}_local`} ON CLUSTER ${props.cluster} (${props.columns})
     ENGINE = ReplicatedMergeTree

package/src/composites/soft-delete-table.ts

@@ -14,6 +14,8 @@
 
 import { Composite } from "@intentius/chant/composite";
 import { index, literal, table, view, type PostgresIndex, type PostgresSchema, type PostgresTable, type PostgresView } from "../postgres/entities";
+import type { PostgresMemberName } from "../core/typed";
+import type { Instance, TypedComposite } from "./typed";
 
 export interface SoftDeleteTableProps {
   /** The table's name, unqualified. The view is `<name>_live`. */
@@ -34,14 +36,19 @@ export interface SoftDeleteTableProps {
   deletedAt?: string;
 }
 
-export type SoftDeleteTableMembers = {
-  table: PostgresTable;
-  live: PostgresView;
+/** `Table` and `Live` are the table's and the view's qualified names, when the call's props give them (chant#3787). */
+export type SoftDeleteTableMembers<Table extends string = string, Live extends string = string> = {
+  table: PostgresTable<Table>;
+  live: PostgresView<Live>;
   liveIndex: PostgresIndex;
 };
 
+type SoftDeleteTableCall = <const N extends string, const S extends PostgresSchema | string = "public">(
+  props: SoftDeleteTableProps & { name: N; schema?: S },
+) => Instance<SoftDeleteTableMembers<PostgresMemberName<S, N>, PostgresMemberName<S, N, "_live">>>;
+
 /** A table with created and updated timestamps and a soft-delete column, a view of its live rows and an index over them. */
-export const SoftDeleteTable = Composite<SoftDeleteTableProps, SoftDeleteTableMembers>((props) => {
+export const SoftDeleteTable = Composite<SoftDeleteTableProps, SoftDeleteTableMembers, TypedComposite<SoftDeleteTableProps, SoftDeleteTableMembers, SoftDeleteTableCall>>((props) => {
   const schema = props.schema ?? "public";
   const deleted = props.deletedAt ?? "deleted_at";
   const rows = table`