@intentius/chant-lexicon-sql 0.0.0-stage → 0.112.1

package/dist/composites/audit-log-table.d.ts

@@ -0,0 +1,31 @@
+/**
+ * `AuditLogTable`: an append-only audit log partitioned by month.
+ *
+ * The parent is `PARTITION BY RANGE (<timestamp>)`, and its primary key
+ * includes the timestamp, which Postgres requires of every unique key on a
+ * partitioned table. The composite declares a default partition so no insert
+ * is refused before a month's partition exists; a partition per month is
+ * created ahead of time by whatever the project uses for partition upkeep (a
+ * `FOR VALUES FROM ('2026-10-01') TO ('2026-11-01')` partition of the parent
+ * is one more `table` call). An index on `(<actor>, <timestamp>)` serves the
+ * question an audit log is asked most: what did this actor do, and when.
+ */
+import { type PostgresIndex, type PostgresSchema, type PostgresTable } from "../postgres/entities.js";
+export interface AuditLogTableProps {
+    /** The table's name, unqualified. The default partition is `<name>_default`. */
+    name: string;
+    /** The schema the table and its partitions live in: the entity, or its name (default `public`). */
+    schema?: PostgresSchema | string;
+    /** The event time column, the partition key (default `occurred_at`). */
+    timestamp?: string;
+    /** The column naming who acted (default `actor`). */
+    actor?: string;
+}
+export type AuditLogTableMembers = {
+    table: PostgresTable;
+    defaultPartition: PostgresTable;
+    actorIndex: PostgresIndex;
+};
+/** An append-only audit log partitioned by month on its timestamp, with a default partition and an index by actor. */
+export declare const AuditLogTable: import("@intentius/chant").CompositeDefinition<AuditLogTableProps, AuditLogTableMembers>;
+//# sourceMappingURL=audit-log-table.d.ts.map

package/dist/composites/audit-log-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-log-table.d.ts","sourceRoot":"","sources":["../../src/composites/audit-log-table.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EAAgB,KAAK,aAAa,EAAE,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAEjH,MAAM,WAAW,kBAAkB;IACjC,gFAAgF;IAChF,IAAI,EAAE,MAAM,CAAC;IACb,mGAAmG;IACnG,MAAM,CAAC,EAAE,cAAc,GAAG,MAAM,CAAC;IACjC,wEAAwE;IACxE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qDAAqD;IACrD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,KAAK,EAAE,aAAa,CAAC;IACrB,gBAAgB,EAAE,aAAa,CAAC;IAChC,UAAU,EAAE,aAAa,CAAC;CAC3B,CAAC;AAEF,sHAAsH;AACtH,eAAO,MAAM,aAAa,0FAmBP,CAAC"}

package/dist/composites/catalog.d.ts

@@ -0,0 +1,3 @@
+import type { CompositeEntry } from "@intentius/chant/lexicon";
+export declare const compositeCatalog: CompositeEntry[];
+//# sourceMappingURL=catalog.d.ts.map

package/dist/composites/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../src/composites/catalog.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE/D,eAAO,MAAM,gBAAgB,EAAE,cAAc,EA2gB5C,CAAC"}

package/dist/composites/cdc-mirror.d.ts

@@ -0,0 +1,32 @@
+/**
+ * `CdcMirror`: a ReplacingMergeTree mirror of a source database table fed by change data capture, with a view of its live rows.
+ *
+ * A CDC pipeline (ClickPipes, Debezium through Kafka, PeerDB) writes every
+ * change to a source row as a new row here, with an increasing version and a
+ * deleted flag. ReplacingMergeTree with both arguments keeps the latest
+ * version per primary key and, on merge, drops rows whose latest version is a
+ * delete. The `current` view reads the table with `FINAL` and without deleted
+ * rows, which is what a query of the source table would have returned.
+ */
+import { type ClickHouseTable, type ClickHouseView } from "../clickhouse/entities.js";
+export interface CdcMirrorProps {
+    /** The mirror table's name. The view of live rows is `<name>_current`. */
+    name: string;
+    /** The source table's columns, as SQL, without the version and deleted columns. */
+    columns: string;
+    /** The source table's primary key, the mirror's sort key: `id` or `(tenant_id, id)`. */
+    primaryKey: string;
+    /** The version column the pipeline writes (default `_version`, UInt64). */
+    version?: string;
+    /** The deleted flag the pipeline writes (default `_is_deleted`, UInt8, 1 for a delete). */
+    deleted?: string;
+    /** A `PARTITION BY` expression. Left out by default. */
+    partitionBy?: string;
+}
+export type CdcMirrorMembers = {
+    table: ClickHouseTable;
+    current: ClickHouseView;
+};
+/** A ReplacingMergeTree mirror of a CDC-fed source table, with a view of the rows not deleted. */
+export declare const CdcMirror: import("@intentius/chant").CompositeDefinition<CdcMirrorProps, CdcMirrorMembers>;
+//# sourceMappingURL=cdc-mirror.d.ts.map

package/dist/composites/cdc-mirror.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cdc-mirror.d.ts","sourceRoot":"","sources":["../../src/composites/cdc-mirror.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,EAAe,KAAK,eAAe,EAAE,KAAK,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAEhG,MAAM,WAAW,cAAc;IAC7B,0EAA0E;IAC1E,IAAI,EAAE,MAAM,CAAC;IACb,mFAAmF;IACnF,OAAO,EAAE,MAAM,CAAC;IAChB,wFAAwF;IACxF,UAAU,EAAE,MAAM,CAAC;IACnB,2EAA2E;IAC3E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,2FAA2F;IAC3F,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,wDAAwD;IACxD,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,EAAE,eAAe,CAAC;IACvB,OAAO,EAAE,cAAc,CAAC;CACzB,CAAC;AAEF,kGAAkG;AAClG,eAAO,MAAM,SAAS,kFAkBP,CAAC"}

package/dist/composites/clickhouse.d.ts

@@ -0,0 +1,7 @@
+/** The ClickHouse composites, exported at `@intentius/chant-lexicon-sql/clickhouse`. */
+export { ReplacingTable, type ReplacingTableProps, type ReplacingTableMembers } from "./replacing-table.js";
+export { EventsTable, type EventsTableProps, type EventsTableMembers } from "./events-table.js";
+export { RollupView, type RollupViewProps, type RollupViewMembers } from "./rollup-view.js";
+export { CdcMirror, type CdcMirrorProps, type CdcMirrorMembers } from "./cdc-mirror.js";
+export { ShardedTable, type ShardedTableProps, type ShardedTableMembers } from "./sharded-table.js";
+//# sourceMappingURL=clickhouse.d.ts.map

package/dist/composites/clickhouse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clickhouse.d.ts","sourceRoot":"","sources":["../../src/composites/clickhouse.ts"],"names":[],"mappings":"AAAA,wFAAwF;AAExF,OAAO,EAAE,cAAc,EAAE,KAAK,mBAAmB,EAAE,KAAK,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AACzG,OAAO,EAAE,WAAW,EAAE,KAAK,gBAAgB,EAAE,KAAK,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAC7F,OAAO,EAAE,UAAU,EAAE,KAAK,eAAe,EAAE,KAAK,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACzF,OAAO,EAAE,SAAS,EAAE,KAAK,cAAc,EAAE,KAAK,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrF,OAAO,EAAE,YAAY,EAAE,KAAK,iBAAiB,EAAE,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/composites/events-table.d.ts

@@ -0,0 +1,32 @@
+/**
+ * `EventsTable`: an append-only MergeTree events table, partitioned by month and expired by TTL.
+ *
+ * The table is partitioned by its timestamp (by month unless `partitionBy`
+ * says otherwise) and drops rows older than `ttlDays`. It sets
+ * `ttl_only_drop_parts`, so expiry drops whole parts once every row in them
+ * has expired instead of rewriting parts to remove single rows, which is cheap
+ * when the partition and the TTL follow the same column.
+ */
+import { type ClickHouseTable } from "../clickhouse/entities.js";
+export interface EventsTableProps {
+    /** The table's name, `name` or `database.name`. */
+    name: string;
+    /** Every column except the timestamp, as SQL: `user_id UUID, kind LowCardinality(String)`. */
+    columns: string;
+    /** The sort key. Put the columns queries filter on first: `(kind, user_id, ts)`. */
+    orderBy: string;
+    /** The timestamp column (default `ts`). TTL and the default partition key read it. */
+    timestamp?: string;
+    /** The timestamp's type (default `DateTime`): a Date, DateTime or DateTime64. */
+    timestampType?: string;
+    /** Days a row is kept (default 90). */
+    ttlDays?: number;
+    /** The partition key (default `toYYYYMM(<timestamp>)`). Keep it no finer than a day. */
+    partitionBy?: string;
+}
+export type EventsTableMembers = {
+    table: ClickHouseTable;
+};
+/** An append-only MergeTree events table, partitioned by its timestamp and expired by TTL. */
+export declare const EventsTable: import("@intentius/chant").CompositeDefinition<EventsTableProps, EventsTableMembers>;
+//# sourceMappingURL=events-table.d.ts.map

package/dist/composites/events-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events-table.d.ts","sourceRoot":"","sources":["../../src/composites/events-table.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAS,KAAK,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAErE,MAAM,WAAW,gBAAgB;IAC/B,mDAAmD;IACnD,IAAI,EAAE,MAAM,CAAC;IACb,8FAA8F;IAC9F,OAAO,EAAE,MAAM,CAAC;IAChB,oFAAoF;IACpF,OAAO,EAAE,MAAM,CAAC;IAChB,sFAAsF;IACtF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iFAAiF;IACjF,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,uCAAuC;IACvC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,wFAAwF;IACxF,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,EAAE,eAAe,CAAC;CACxB,CAAC;AAEF,8FAA8F;AAC9F,eAAO,MAAM,WAAW,sFAaP,CAAC"}

package/dist/composites/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The sql lexicon's composites: tables and views that are usually declared
+ * together, built from each dialect's `table`, `index` and `view` tags so every
+ * field keeps its provenance. `./clickhouse` and `./postgres` are what the two
+ * dialect subpaths export.
+ */
+export * from "./clickhouse.js";
+export * from "./postgres.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/composites/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/composites/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC"}

package/dist/composites/join-table.d.ts

@@ -0,0 +1,41 @@
+/**
+ * `JoinTable`: the table of a many-to-many relation, with both foreign keys indexed.
+ *
+ * The primary key is `(<leftColumn>, <rightColumn>)`, which also serves
+ * lookups from the left side. The reverse index on `(<rightColumn>,
+ * <leftColumn>)` serves lookups from the right and keeps deletes of a
+ * referenced row off a table scan (SQLPG102). Each foreign key cascades by
+ * default, so deleting a row on either side removes its links.
+ */
+import { type PostgresIndex, type PostgresSchema, type PostgresTable } from "../postgres/entities.js";
+export interface JoinTableProps {
+    /** The table's name, unqualified. The reverse index is `<name>_reverse_idx`. */
+    name: string;
+    /** The schema the table lives in: the entity, or its name (default `public`). */
+    schema?: PostgresSchema | string;
+    /** The table on the left of the relation, as the entity. */
+    left: PostgresTable;
+    /** The column on the left table the key references (default `id`). */
+    leftKey?: string;
+    /** The join table's column holding the left key: `user_id`. */
+    leftColumn: string;
+    /** The left column's type (default `bigint`). */
+    leftType?: string;
+    /** The table on the right of the relation, as the entity. */
+    right: PostgresTable;
+    /** The column on the right table the key references (default `id`). */
+    rightKey?: string;
+    /** The join table's column holding the right key: `team_id`. */
+    rightColumn: string;
+    /** The right column's type (default `bigint`). */
+    rightType?: string;
+    /** What happens to a link when the row it references is deleted (default `CASCADE`). */
+    onDelete?: string;
+}
+export type JoinTableMembers = {
+    table: PostgresTable;
+    reverseIndex: PostgresIndex;
+};
+/** The table of a many-to-many relation: two foreign keys, a composite primary key and the reverse index. */
+export declare const JoinTable: import("@intentius/chant").CompositeDefinition<JoinTableProps, JoinTableMembers>;
+//# sourceMappingURL=join-table.d.ts.map

package/dist/composites/join-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"join-table.d.ts","sourceRoot":"","sources":["../../src/composites/join-table.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAgB,KAAK,aAAa,EAAE,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAEjH,MAAM,WAAW,cAAc;IAC7B,gFAAgF;IAChF,IAAI,EAAE,MAAM,CAAC;IACb,iFAAiF;IACjF,MAAM,CAAC,EAAE,cAAc,GAAG,MAAM,CAAC;IACjC,4DAA4D;IAC5D,IAAI,EAAE,aAAa,CAAC;IACpB,sEAAsE;IACtE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+DAA+D;IAC/D,UAAU,EAAE,MAAM,CAAC;IACnB,iDAAiD;IACjD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6DAA6D;IAC7D,KAAK,EAAE,aAAa,CAAC;IACrB,uEAAuE;IACvE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gEAAgE;IAChE,WAAW,EAAE,MAAM,CAAC;IACpB,kDAAkD;IAClD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wFAAwF;IACxF,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,EAAE,aAAa,CAAC;IACrB,YAAY,EAAE,aAAa,CAAC;CAC7B,CAAC;AAEF,6GAA6G;AAC7G,eAAO,MAAM,SAAS,kFAYP,CAAC"}

package/dist/composites/postgres.d.ts

@@ -0,0 +1,7 @@
+/** The Postgres composites, exported at `@intentius/chant-lexicon-sql/postgres`. */
+export { SoftDeleteTable, type SoftDeleteTableProps, type SoftDeleteTableMembers } from "./soft-delete-table.js";
+export { AuditLogTable, type AuditLogTableProps, type AuditLogTableMembers } from "./audit-log-table.js";
+export { JoinTable, type JoinTableProps, type JoinTableMembers } from "./join-table.js";
+export { TenantTable, type TenantTableProps, type TenantTableMembers } from "./tenant-table.js";
+export { RefreshedView, type RefreshedViewProps, type RefreshedViewMembers } from "./refreshed-view.js";
+//# sourceMappingURL=postgres.d.ts.map

package/dist/composites/postgres.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.d.ts","sourceRoot":"","sources":["../../src/composites/postgres.ts"],"names":[],"mappings":"AAAA,oFAAoF;AAEpF,OAAO,EAAE,eAAe,EAAE,KAAK,oBAAoB,EAAE,KAAK,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAC9G,OAAO,EAAE,aAAa,EAAE,KAAK,kBAAkB,EAAE,KAAK,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACtG,OAAO,EAAE,SAAS,EAAE,KAAK,cAAc,EAAE,KAAK,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrF,OAAO,EAAE,WAAW,EAAE,KAAK,gBAAgB,EAAE,KAAK,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAC7F,OAAO,EAAE,aAAa,EAAE,KAAK,kBAAkB,EAAE,KAAK,oBAAoB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/composites/refreshed-view.d.ts

@@ -0,0 +1,32 @@
+/**
+ * `RefreshedView`: a materialized view with the unique index that lets it refresh concurrently.
+ *
+ * `REFRESH MATERIALIZED VIEW CONCURRENTLY` needs at least one unique index
+ * over plain columns, and without it every refresh takes an ACCESS EXCLUSIVE
+ * lock that blocks readers (SQLPG111). The composite declares the view and
+ * that index together, so a view cannot be added without one. The view reads
+ * `source` by reference, so the build orders them and the view's lineage
+ * names the source's columns.
+ */
+import { type PostgresIndex, type PostgresRelation, type PostgresSchema, type PostgresView } from "../postgres/entities.js";
+export interface RefreshedViewProps {
+    /** The view's name, unqualified. The index is `<name>_key`. */
+    name: string;
+    /** The schema the view lives in: the entity, or its name (default `public`). */
+    schema?: PostgresSchema | string;
+    /** The table or view the materialized view reads, as the entity. */
+    source: PostgresRelation;
+    /** The select list, each computed item aliased: `region, count(*) AS orders, sum(total) AS revenue`. */
+    select: string;
+    /** The grouping key: `region`. */
+    groupBy: string;
+    /** The columns of the unique index, which must identify one row of the result (default `groupBy`). */
+    uniqueOn?: string;
+}
+export type RefreshedViewMembers = {
+    view: PostgresView;
+    uniqueIndex: PostgresIndex;
+};
+/** A materialized view over a source, with the unique index that allows REFRESH ... CONCURRENTLY. */
+export declare const RefreshedView: import("@intentius/chant").CompositeDefinition<RefreshedViewProps, RefreshedViewMembers>;
+//# sourceMappingURL=refreshed-view.d.ts.map

package/dist/composites/refreshed-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refreshed-view.d.ts","sourceRoot":"","sources":["../../src/composites/refreshed-view.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,EAAe,KAAK,aAAa,EAAE,KAAK,gBAAgB,EAAE,KAAK,cAAc,EAAE,KAAK,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEtI,MAAM,WAAW,kBAAkB;IACjC,+DAA+D;IAC/D,IAAI,EAAE,MAAM,CAAC;IACb,gFAAgF;IAChF,MAAM,CAAC,EAAE,cAAc,GAAG,MAAM,CAAC;IACjC,oEAAoE;IACpE,MAAM,EAAE,gBAAgB,CAAC;IACzB,wGAAwG;IACxG,MAAM,EAAE,MAAM,CAAC;IACf,kCAAkC;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,sGAAsG;IACtG,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,YAAY,CAAC;IACnB,WAAW,EAAE,aAAa,CAAC;CAC5B,CAAC;AAEF,qGAAqG;AACrG,eAAO,MAAM,aAAa,0FAUP,CAAC"}

package/dist/composites/replacing-table.d.ts

@@ -0,0 +1,34 @@
+/**
+ * `ReplacingTable`: a ReplacingMergeTree table with a version column.
+ *
+ * ReplacingMergeTree keeps one row per sort key. When a merge meets rows with
+ * the same key it keeps the one with the highest version, so writing a row
+ * again with a higher version is how an update is expressed. Until a merge
+ * runs, a query sees every version; read with `FINAL`, or aggregate with
+ * `argMax`, when the latest row is what you want.
+ *
+ * Every field is built from a parameter or fixed by the template, inside the
+ * subset `chant build` interprets, so a drift on the table is reported against
+ * the parameter that produced the field when the composite is interpreted.
+ */
+import { type ClickHouseTable } from "../clickhouse/entities.js";
+export interface ReplacingTableProps {
+    /** The table's name, `name` or `database.name`. */
+    name: string;
+    /** Every column except the version column, as SQL: `id UInt64, email String`. */
+    columns: string;
+    /** The sort key, which is also the key rows are deduplicated by: `id` or `(tenant_id, id)`. */
+    orderBy: string;
+    /** The version column (default `version`). The row with the highest version survives a merge. */
+    version?: string;
+    /** The version column's type (default `UInt64`): a UInt, Date, DateTime or DateTime64. */
+    versionType?: string;
+    /** A `PARTITION BY` expression. Left out by default: a deduplicating table is usually small enough not to need one. */
+    partitionBy?: string;
+}
+export type ReplacingTableMembers = {
+    table: ClickHouseTable;
+};
+/** A ReplacingMergeTree table that keeps the highest version of each row, with its version column. */
+export declare const ReplacingTable: import("@intentius/chant").CompositeDefinition<ReplacingTableProps, ReplacingTableMembers>;
+//# sourceMappingURL=replacing-table.d.ts.map

package/dist/composites/replacing-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replacing-table.d.ts","sourceRoot":"","sources":["../../src/composites/replacing-table.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAS,KAAK,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAErE,MAAM,WAAW,mBAAmB;IAClC,mDAAmD;IACnD,IAAI,EAAE,MAAM,CAAC;IACb,iFAAiF;IACjF,OAAO,EAAE,MAAM,CAAC;IAChB,+FAA+F;IAC/F,OAAO,EAAE,MAAM,CAAC;IAChB,iGAAiG;IACjG,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,0FAA0F;IAC1F,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,uHAAuH;IACvH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,KAAK,EAAE,eAAe,CAAC;CACxB,CAAC;AAEF,sGAAsG;AACtG,eAAO,MAAM,cAAc,4FAWP,CAAC"}

package/dist/composites/rollup-view.d.ts

@@ -0,0 +1,39 @@
+/**
+ * `RollupView`: a materialized view that rolls a source table up into its own target table.
+ *
+ * The target is a SummingMergeTree (or another engine named by `engine`)
+ * sorted by the rollup's grouping key. The materialized view writes into it
+ * with `TO`, so the target is an ordinary table that can be queried, altered
+ * and backfilled on its own, and dropping the view leaves the data. Every
+ * column the select list writes has to be one the target declares
+ * (SQLCH110), so alias each select item to a target column.
+ *
+ * The view reads `source` by reference, so it depends on the source and on
+ * its target, and the build orders all three.
+ */
+import { type ClickHouseRelation, type ClickHouseTable, type ClickHouseView } from "../clickhouse/entities.js";
+export interface RollupViewProps {
+    /** The target table's name. The view is `<name>_mv`. */
+    name: string;
+    /** The table or view the rollup reads, as the entity: `events`. */
+    source: ClickHouseRelation;
+    /** The target's columns, as SQL: `day Date, kind LowCardinality(String), n UInt64`. */
+    columns: string;
+    /** The select list, each item aliased to a target column: `toDate(ts) AS day, kind, count() AS n`. */
+    select: string;
+    /** The grouping key: `day, kind`. */
+    groupBy: string;
+    /** The target's sort key (default `groupBy` in parentheses). Summing collapses rows that share it. */
+    orderBy?: string;
+    /** The target's engine (default `SummingMergeTree`). Use `AggregatingMergeTree` for `-State` columns. */
+    engine?: string;
+    /** The target's partition key. Left out by default. */
+    partitionBy?: string;
+}
+export type RollupViewMembers = {
+    table: ClickHouseTable;
+    view: ClickHouseView;
+};
+/** A materialized view that rolls a source table up into a target table it declares beside it. */
+export declare const RollupView: import("@intentius/chant").CompositeDefinition<RollupViewProps, RollupViewMembers>;
+//# sourceMappingURL=rollup-view.d.ts.map

package/dist/composites/rollup-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rollup-view.d.ts","sourceRoot":"","sources":["../../src/composites/rollup-view.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAe,KAAK,kBAAkB,EAAE,KAAK,eAAe,EAAE,KAAK,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAEzH,MAAM,WAAW,eAAe;IAC9B,wDAAwD;IACxD,IAAI,EAAE,MAAM,CAAC;IACb,mEAAmE;IACnE,MAAM,EAAE,kBAAkB,CAAC;IAC3B,uFAAuF;IACvF,OAAO,EAAE,MAAM,CAAC;IAChB,sGAAsG;IACtG,MAAM,EAAE,MAAM,CAAC;IACf,qCAAqC;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,sGAAsG;IACtG,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,yGAAyG;IACzG,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uDAAuD;IACvD,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,EAAE,eAAe,CAAC;IACvB,IAAI,EAAE,cAAc,CAAC;CACtB,CAAC;AAEF,kGAAkG;AAClG,eAAO,MAAM,UAAU,oFAYP,CAAC"}

package/dist/composites/sharded-table.d.ts

@@ -0,0 +1,35 @@
+/**
+ * `ShardedTable`: a ReplicatedMergeTree table on every node of a cluster and the Distributed table that spreads reads and writes across it.
+ *
+ * Both tables are created `ON CLUSTER`. The local table, `<name>_local`, holds
+ * each shard's rows and replicates them within the shard; with no engine
+ * arguments it takes the server's default replication path. The Distributed
+ * table, `<name>`, holds no data: an insert goes to one shard by the sharding
+ * key, and a query runs on every shard and merges the results.
+ *
+ * The Distributed table reads the local one by reference, so the build creates
+ * the local table first. Give `name` without a database: the Distributed
+ * engine names its table in the current database.
+ */
+import { type ClickHouseTable } from "../clickhouse/entities.js";
+export interface ShardedTableProps {
+    /** The Distributed table's name, unqualified. The local table is `<name>_local`. */
+    name: string;
+    /** The cluster both tables are created on, as the server's `remote_servers` names it. */
+    cluster: string;
+    /** The columns, as SQL. Both tables declare the same list. */
+    columns: string;
+    /** The local table's sort key. */
+    orderBy: string;
+    /** The expression that picks a shard for an inserted row (default `rand()`). */
+    shardingKey?: string;
+    /** The local table's partition key. Left out by default. */
+    partitionBy?: string;
+}
+export type ShardedTableMembers = {
+    local: ClickHouseTable;
+    distributed: ClickHouseTable;
+};
+/** A ReplicatedMergeTree table on every node of a cluster and the Distributed table over it. */
+export declare const ShardedTable: import("@intentius/chant").CompositeDefinition<ShardedTableProps, ShardedTableMembers>;
+//# sourceMappingURL=sharded-table.d.ts.map

package/dist/composites/sharded-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sharded-table.d.ts","sourceRoot":"","sources":["../../src/composites/sharded-table.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAAS,KAAK,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAErE,MAAM,WAAW,iBAAiB;IAChC,oFAAoF;IACpF,IAAI,EAAE,MAAM,CAAC;IACb,yFAAyF;IACzF,OAAO,EAAE,MAAM,CAAC;IAChB,8DAA8D;IAC9D,OAAO,EAAE,MAAM,CAAC;IAChB,kCAAkC;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,gFAAgF;IAChF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4DAA4D;IAC5D,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,eAAe,CAAC;IACvB,WAAW,EAAE,eAAe,CAAC;CAC9B,CAAC;AAEF,gGAAgG;AAChG,eAAO,MAAM,YAAY,wFAUP,CAAC"}

package/dist/composites/soft-delete-table.d.ts

@@ -0,0 +1,40 @@
+/**
+ * `SoftDeleteTable`: a table whose rows carry created and updated timestamps and are deleted by marking them.
+ *
+ * The composite appends `created_at` and `updated_at` (both `timestamptz NOT
+ * NULL DEFAULT now()`) and a nullable `deleted_at` to the columns it is
+ * given. A row is live while `deleted_at` is null. The `<name>_live` view
+ * reads the live rows (it sets `security_invoker`, so row-level security on
+ * the table applies to whoever reads the view), and a partial index on the
+ * live rows keeps lookups by the key the app uses off the dead ones.
+ *
+ * Postgres has no column default that follows an update: the app, or a
+ * trigger it owns, sets `updated_at`.
+ */
+import { type PostgresIndex, type PostgresSchema, type PostgresTable, type PostgresView } from "../postgres/entities.js";
+export interface SoftDeleteTableProps {
+    /** The table's name, unqualified. The view is `<name>_live`. */
+    name: string;
+    /** The schema the table, its index and its view live in: the entity, or its name (default `public`). */
+    schema?: PostgresSchema | string;
+    /** Every column except the three the composite adds, as SQL, with the primary key: `id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY, title text NOT NULL`. */
+    columns: string;
+    /** The column the live-rows index covers: the one the app looks rows up by, as SQL (default `id`). */
+    liveKey?: string;
+    /** The table's comment, which also covers its columns for SQLPG112 (default: says rows are soft-deleted). */
+    comment?: string;
+    /** The creation timestamp column (default `created_at`). */
+    createdAt?: string;
+    /** The update timestamp column (default `updated_at`). */
+    updatedAt?: string;
+    /** The deletion timestamp column (default `deleted_at`). Null means the row is live. */
+    deletedAt?: string;
+}
+export type SoftDeleteTableMembers = {
+    table: PostgresTable;
+    live: PostgresView;
+    liveIndex: PostgresIndex;
+};
+/** A table with created and updated timestamps and a soft-delete column, a view of its live rows and an index over them. */
+export declare const SoftDeleteTable: import("@intentius/chant").CompositeDefinition<SoftDeleteTableProps, SoftDeleteTableMembers>;
+//# sourceMappingURL=soft-delete-table.d.ts.map

package/dist/composites/soft-delete-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"soft-delete-table.d.ts","sourceRoot":"","sources":["../../src/composites/soft-delete-table.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EAA+B,KAAK,aAAa,EAAE,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,KAAK,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEnJ,MAAM,WAAW,oBAAoB;IACnC,gEAAgE;IAChE,IAAI,EAAE,MAAM,CAAC;IACb,wGAAwG;IACxG,MAAM,CAAC,EAAE,cAAc,GAAG,MAAM,CAAC;IACjC,iKAAiK;IACjK,OAAO,EAAE,MAAM,CAAC;IAChB,sGAAsG;IACtG,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,6GAA6G;IAC7G,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4DAA4D;IAC5D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,0DAA0D;IAC1D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wFAAwF;IACxF,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,KAAK,EAAE,aAAa,CAAC;IACrB,IAAI,EAAE,YAAY,CAAC;IACnB,SAAS,EAAE,aAAa,CAAC;CAC1B,CAAC;AAEF,4HAA4H;AAC5H,eAAO,MAAM,eAAe,8FAiBP,CAAC"}

package/dist/composites/tenant-table.d.ts

@@ -0,0 +1,34 @@
+/**
+ * `TenantTable`: a multi-tenant table whose tenant key leads every key and index.
+ *
+ * The composite adds the tenant column (`NOT NULL`) in front of the columns it
+ * is given, makes the primary key `(<tenant>, <primaryKey>)` and creates one
+ * index on `(<tenant>, <indexOn>)`. With the tenant first in each, a query
+ * scoped to one tenant reads one contiguous range of every index, and no index
+ * serves a cross-tenant scan by accident. Row-level security is separate: a
+ * policy on the table is what keeps one tenant's role out of another's rows.
+ */
+import { type PostgresIndex, type PostgresSchema, type PostgresTable } from "../postgres/entities.js";
+export interface TenantTableProps {
+    /** The table's name, unqualified. The index is `<name>_tenant_idx`. */
+    name: string;
+    /** The schema the table lives in: the entity, or its name (default `public`). */
+    schema?: PostgresSchema | string;
+    /** Every column except the tenant's, as SQL: `id bigint GENERATED ALWAYS AS IDENTITY, title text NOT NULL`. */
+    columns: string;
+    /** The columns that, after the tenant, make a row unique: `id`. */
+    primaryKey: string;
+    /** The columns the secondary index covers after the tenant: `created_at DESC`. */
+    indexOn: string;
+    /** The tenant column (default `tenant_id`). */
+    tenant?: string;
+    /** The tenant column's type (default `uuid`). */
+    tenantType?: string;
+}
+export type TenantTableMembers = {
+    table: PostgresTable;
+    index: PostgresIndex;
+};
+/** A multi-tenant table with the tenant key first in its primary key and its index. */
+export declare const TenantTable: import("@intentius/chant").CompositeDefinition<TenantTableProps, TenantTableMembers>;
+//# sourceMappingURL=tenant-table.d.ts.map

package/dist/composites/tenant-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tenant-table.d.ts","sourceRoot":"","sources":["../../src/composites/tenant-table.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,EAAgB,KAAK,aAAa,EAAE,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAEjH,MAAM,WAAW,gBAAgB;IAC/B,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAC;IACb,iFAAiF;IACjF,MAAM,CAAC,EAAE,cAAc,GAAG,MAAM,CAAC;IACjC,+GAA+G;IAC/G,OAAO,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,UAAU,EAAE,MAAM,CAAC;IACnB,kFAAkF;IAClF,OAAO,EAAE,MAAM,CAAC;IAChB,+CAA+C;IAC/C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iDAAiD;IACjD,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,EAAE,aAAa,CAAC;IACrB,KAAK,EAAE,aAAa,CAAC;CACtB,CAAC;AAEF,uFAAuF;AACvF,eAAO,MAAM,WAAW,sFAYP,CAAC"}