@intentius/chant-lexicon-sql 0.124.18 → 0.124.21

package/src/postgres/entities.ts

@@ -1,8 +1,9 @@
 /**
  * The Postgres entities: `schema`, `table`, `index`, `view`, `sequence`,
- * `type`, `domain`, `extension`, `func`, `procedure`, `trigger`, `policy`,
- * `role` and `grant` tagged templates that parse their DDL at fold time into
- * one Declarable each (chant #3278, #3279, #3680, #3681).
+ * `type` (enum, composite and range), `domain`, `extension`, `func`,
+ * `procedure`, `aggregate`, `trigger`, `eventTrigger`, `collation`, `cast`,
+ * `policy`, `role` and `grant` tagged templates that parse their DDL at fold
+ * time into one Declarable each (chant #3278, #3279, #3680, #3681, #3911).
  *
  * ```ts
  * import { schema, table, index } from "@intentius/chant-lexicon-sql/postgres";
@@ -56,7 +57,7 @@
 import type { AttrRef } from "@intentius/chant/attrref";
 import { setInterpolationFields } from "@intentius/chant/provenance";
 import { isTrivia, POSTGRES_LEXICAL, SqlSyntaxError, untokenize, type Token } from "./tokens";
-import { identValue, parseStatements, type ColumnNode, type CommentNode, type ConstraintNode, type GrantNode, type NameNode, type RowSecurityNode, type Span, type StatementNode } from "./parser";
+import { identValue, parseStatements, type ColumnNode, type CommentNode, type ConstraintNode, type DefElem, type GrantNode, type NameNode, type RowSecurityNode, type Span, type StatementNode } from "./parser";
 import { keywordCategory, quoteIdent } from "./keywords";
 import { feed, lineage, spanText as text, splice as spliceWith, templateSyntaxError, unparsedClauses, type TemplateCtx, type TemplateDialect, type UnparsedClause } from "../core/interpolation";
 import { SqlObject, isColumnRefOf, isSqlObjectOf, makeSqlEntity } from "../core/entity";
@@ -260,6 +261,86 @@ export interface EnumProps extends CommonProps {
   labels: string[];
 }
 
+/** A composite type's attribute, as written. */
+export interface CompositeAttributeDef {
+  name: string;
+  type: string;
+  collate?: string;
+}
+
+export interface CompositeTypeProps extends CommonProps {
+  attributes: CompositeAttributeDef[];
+}
+
+export interface RangeTypeProps extends CommonProps {
+  /** `SUBTYPE`: the element type. */
+  subtype: string;
+  subtypeOpclass?: string;
+  collation?: string;
+  /** `CANONICAL`: the function that canonicalizes a value (a C function). */
+  canonical?: string;
+  subtypeDiff?: string;
+  /** `MULTIRANGE_TYPE_NAME`: the multirange type's name, when it is not the one Postgres derives. */
+  multirangeTypeName?: string;
+}
+
+/** One argument of an aggregate, as written. */
+export interface AggregateArgDef {
+  /** `in` when not written. */
+  mode: "in" | "variadic";
+  name?: string;
+  type: string;
+}
+
+export interface AggregateProps extends CommonProps {
+  orReplace?: boolean;
+  /** The arguments; empty for `(*)`. An ordered-set aggregate's direct arguments. */
+  args: AggregateArgDef[];
+  /** An ordered-set aggregate's aggregated arguments (`ORDER BY ...`). */
+  orderBy?: AggregateArgDef[];
+  /**
+   * The definition: each option by its name, folded (`sfunc`, `stype`,
+   * `initcond`), to its value as written; an option given without a value
+   * (`HYPOTHETICAL`, `FINALFUNC_EXTRA`) to `true`.
+   */
+  options: Record<string, string>;
+}
+
+export interface CollationProps extends CommonProps {
+  ifNotExists?: boolean;
+  /** Each option by its name, folded (`provider`, `locale`, `deterministic`), to its value as written. */
+  options: Record<string, string>;
+}
+
+export interface CastProps extends Omit<CommonProps, "schema"> {
+  /** `(source AS target)`: a cast is named by its two types and lives in no schema. */
+  name: string;
+  /** The source type as written. */
+  sourceType: string;
+  /** The target type as written. */
+  targetType: string;
+  /** `WITH FUNCTION` (`function`), `WITHOUT FUNCTION` (`binary`) or `WITH INOUT` (`inout`). */
+  method: "function" | "binary" | "inout";
+  /** The cast function: the entity when interpolated, else its name. */
+  function?: PostgresObject | string;
+  /** The cast function's SQL name. */
+  functionName?: string;
+  /** The cast function's parameter types, when written. */
+  functionArgs?: string;
+  /** `explicit` (the default), `AS ASSIGNMENT` or `AS IMPLICIT`. */
+  context: "explicit" | "assignment" | "implicit";
+}
+
+export interface EventTriggerProps extends Omit<CommonProps, "schema"> {
+  /** `ddl_command_start`, `ddl_command_end`, `sql_drop`, `table_rewrite` or `login`. */
+  event: string;
+  /** `WHEN TAG IN (...)`: the command tags it fires for; every one when absent. */
+  tags?: string[];
+  /** The function it executes: the entity when interpolated, else its name. */
+  function: PostgresObject | string;
+  functionName: string;
+}
+
 export interface DomainProps extends CommonProps {
   /** The underlying data type. */
   dataType: string;
@@ -488,11 +569,44 @@ export interface PostgresEnum extends PostgresObject {
   readonly props: EnumProps;
 }
 
+export interface PostgresCompositeType extends PostgresObject {
+  readonly entityType: "Postgres::CompositeType";
+  readonly props: CompositeTypeProps;
+}
+
+export interface PostgresRangeType extends PostgresObject {
+  readonly entityType: "Postgres::RangeType";
+  readonly props: RangeTypeProps;
+}
+
+/** What the `type` tag declares: an enum, a composite or a range type. */
+export type PostgresType = PostgresEnum | PostgresCompositeType | PostgresRangeType;
+
 export interface PostgresDomain extends PostgresObject {
   readonly entityType: "Postgres::Domain";
   readonly props: DomainProps;
 }
 
+export interface PostgresAggregate extends PostgresObject {
+  readonly entityType: "Postgres::Aggregate";
+  readonly props: AggregateProps;
+}
+
+export interface PostgresCollation extends PostgresObject {
+  readonly entityType: "Postgres::Collation";
+  readonly props: CollationProps;
+}
+
+export interface PostgresCast extends PostgresObject {
+  readonly entityType: "Postgres::Cast";
+  readonly props: CastProps;
+}
+
+export interface PostgresEventTrigger extends PostgresObject {
+  readonly entityType: "Postgres::EventTrigger";
+  readonly props: EventTriggerProps;
+}
+
 export interface PostgresExtension extends PostgresObject {
   readonly entityType: "Postgres::Extension";
   readonly props: ExtensionProps;
@@ -637,23 +751,46 @@ export const POSTGRES_TEMPLATES: TemplateDialect = {
 
 type Ctx = TemplateCtx;
 
-export type PostgresTag = "schema" | "table" | "index" | "view" | "sequence" | "type" | "domain" | "extension" | "func" | "procedure" | "trigger" | "policy" | "role" | "grant";
-
-const STATEMENT_OF: Record<PostgresTag, StatementNode["statement"]> = {
-  schema: "schema",
-  table: "table",
-  index: "index",
-  view: "view",
-  sequence: "sequence",
-  type: "enum",
-  domain: "domain",
-  extension: "extension",
-  func: "function",
-  procedure: "procedure",
-  trigger: "trigger",
-  policy: "policy",
-  role: "role",
-  grant: "grant",
+export type PostgresTag =
+  | "schema"
+  | "table"
+  | "index"
+  | "view"
+  | "sequence"
+  | "type"
+  | "domain"
+  | "extension"
+  | "func"
+  | "procedure"
+  | "aggregate"
+  | "trigger"
+  | "eventTrigger"
+  | "collation"
+  | "cast"
+  | "policy"
+  | "role"
+  | "grant";
+
+/** The statements each tag holds. */
+export const STATEMENTS_OF: Record<PostgresTag, readonly StatementNode["statement"][]> = {
+  schema: ["schema"],
+  table: ["table"],
+  index: ["index"],
+  view: ["view"],
+  sequence: ["sequence"],
+  type: ["enum", "composite", "range"],
+  domain: ["domain"],
+  extension: ["extension"],
+  func: ["function"],
+  procedure: ["procedure"],
+  aggregate: ["aggregate"],
+  trigger: ["trigger"],
+  eventTrigger: ["eventTrigger"],
+  collation: ["collation"],
+  cast: ["cast"],
+  policy: ["policy"],
+  role: ["role"],
+  grant: ["grant"],
 };
 
 const TAG_OF: Record<StatementNode["statement"], PostgresTag | undefined> = {
@@ -663,11 +800,17 @@ const TAG_OF: Record<StatementNode["statement"], PostgresTag | undefined> = {
   view: "view",
   sequence: "sequence",
   enum: "type",
+  composite: "type",
+  range: "type",
   domain: "domain",
   extension: "extension",
   function: "func",
   procedure: "procedure",
+  aggregate: "aggregate",
   trigger: "trigger",
+  eventTrigger: "eventTrigger",
+  collation: "collation",
+  cast: "cast",
   policy: "policy",
   role: "role",
   grant: "grant",
@@ -683,11 +826,17 @@ export const STATEMENT_NAMES: Record<StatementNode["statement"], string> = {
   view: "CREATE VIEW",
   sequence: "CREATE SEQUENCE",
   enum: "CREATE TYPE",
+  composite: "CREATE TYPE",
+  range: "CREATE TYPE",
   domain: "CREATE DOMAIN",
   extension: "CREATE EXTENSION",
   function: "CREATE FUNCTION",
   procedure: "CREATE PROCEDURE",
+  aggregate: "CREATE AGGREGATE",
   trigger: "CREATE TRIGGER",
+  eventTrigger: "CREATE EVENT TRIGGER",
+  collation: "CREATE COLLATION",
+  cast: "CREATE CAST",
   policy: "CREATE POLICY",
   role: "CREATE ROLE",
   grant: "GRANT",
@@ -715,6 +864,13 @@ export function stringValue(s: string | undefined): string | undefined {
   return s;
 }
 
+/** A definition list's values, by option name: each value as written, interpolations rendered; an option with no value is `true`. */
+function definitionValues(ctx: Ctx, elems: readonly DefElem[], path: string): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const e of elems) out[e.name] = e.value ? req(text(ctx, e.value, path)) : "true";
+  return out;
+}
+
 /** A qualified name's schema and name. An interpolated schema names the schema; an interpolated object gives both. */
 function qualified(ctx: Ctx, n: NameNode): { schema?: string; name: string } {
   const pieces: string[] = [];
@@ -926,7 +1082,12 @@ function applyComments(
       if (value !== undefined) constraint!.comment = value;
     } else {
       if (!objectTypes.includes(c.objectType)) refuse(c, `does not comment on the ${tag} this template declares`);
-      if (c.objectType === "TRIGGER" || c.objectType === "POLICY") {
+      if (c.objectType === "CAST") {
+        // `COMMENT ON CAST (source AS target)`: the two types, as the CREATE CAST writes them.
+        const loose = (x: string) => x.toLowerCase().replace(/\s+/g, " ").replace(/\s*([(),.])\s*/g, "$1");
+        const named = `(${req(text(ctx, c.cast!.source))} AS ${req(text(ctx, c.cast!.target))})`;
+        if (loose(named) !== loose(self.name)) refuse(c, `names another cast than ${self.name}`);
+      } else if (c.objectType === "TRIGGER" || c.objectType === "POLICY") {
         // `COMMENT ON TRIGGER name ON table`: the name is the trigger's, the table its own.
         if (qualified(ctx, c.target).name !== self.name || !c.on || !isSelf({ ...qualified(ctx, c.on), name: self.name })) refuse(c, `names another ${c.objectType.toLowerCase()} than ${self.name}`);
       } else if (!isSelf(qualified(ctx, c.target))) refuse(c, `names another object than ${sqlNameOf(self)}`);
@@ -1152,7 +1313,7 @@ function build(tag: PostgresTag, strings: TemplateStringsArray | readonly string
     throw templateSyntaxError(tag, parts, err);
   }
   const [node, ...rest] = nodes as [StatementNode, ...StatementNode[]];
-  if (node.statement !== STATEMENT_OF[tag]) {
+  if (!STATEMENTS_OF[tag].includes(node.statement)) {
     const holds = STATEMENT_NAMES[node.statement];
     const use = TAG_OF[node.statement];
     throw new SqlTemplateError(
@@ -1194,9 +1355,9 @@ function build(tag: PostgresTag, strings: TemplateStringsArray | readonly string
   const dependsOn = [...new Set([...values, ...(joined?.refs ?? [])].filter((v) => isPostgresObject(v) || isColumnRef(v)))];
   const slots: TypedSlot[] = [];
   const unparsed = unparsedClauses(ctx, nodes.flatMap((n) => ("unknown" in n && n.unknown ? n.unknown : [])));
-  const make = <T extends PostgresObject>(type: PostgresEntityType, q: { schema?: string; name: string }, props: object, columnNames?: readonly string[]): T => {
+  const make = <T extends PostgresObject>(type: PostgresEntityType, q: { schema?: string; name: string }, props: object, columnNames?: readonly string[], sqlName = sqlNameOf(q)): T => {
     if (unparsed) (props as { unparsed?: UnparsedClause[] }).unparsed = unparsed;
-    const entity = makeSqlEntity(PostgresObject.prototype as PostgresObject, type, sqlNameOf(q), props, columnNames, dependsOn) as T;
+    const entity = makeSqlEntity(PostgresObject.prototype as PostgresObject, type, sqlName, props, columnNames, dependsOn) as T;
     const fed = ctx.fed.map((paths) => [...paths].sort());
     if (!joined) setInterpolationFields(entity, fed);
     else {
@@ -1239,6 +1400,99 @@ function build(tag: PostgresTag, strings: TemplateStringsArray | readonly string
       const props: EnumProps = stripUnset({ ...q, labels: node.labels.map((l) => req(stringValue(text(ctx, l, "labels")))), comment, ddl, source });
       return make(POSTGRES_ENTITY_TYPES.enum, q, props);
     }
+    case "composite": {
+      const q = qualified(ctx, node.name);
+      const comment = applyComments(tag, ctx, comments, q, ["TYPE"]);
+      const attributes = node.attributes.map((a) => {
+        feed(ctx, a.nameSpan, "attributes");
+        return stripUnset({ name: columnName(ctx, { name: a.name, span: a.nameSpan }), type: req(text(ctx, a.type, "attributes")), collate: text(ctx, a.collate, "attributes") }) as CompositeAttributeDef;
+      });
+      const props: CompositeTypeProps = strip({ ...q, attributes, comment, ddl, source }, ["attributes"]);
+      return make(POSTGRES_ENTITY_TYPES.composite, q, props);
+    }
+    case "range": {
+      const q = qualified(ctx, node.name);
+      const comment = applyComments(tag, ctx, comments, q, ["TYPE"]);
+      const opt = definitionValues(ctx, node.options, "options");
+      const props: RangeTypeProps = stripUnset({
+        ...q,
+        subtype: req(opt.subtype),
+        subtypeOpclass: opt.subtype_opclass,
+        collation: opt.collation,
+        canonical: opt.canonical,
+        subtypeDiff: opt.subtype_diff,
+        multirangeTypeName: opt.multirange_type_name,
+        comment,
+        ddl,
+        source,
+      });
+      return make(POSTGRES_ENTITY_TYPES.range, q, props);
+    }
+    case "aggregate": {
+      const q = qualified(ctx, node.name);
+      const comment = applyComments(tag, ctx, comments, q, ["AGGREGATE"]);
+      const arg = (a: (typeof node.args)[number]): AggregateArgDef => stripUnset({ mode: (a.mode?.toLowerCase() ?? "in") as AggregateArgDef["mode"], name: a.name, type: req(text(ctx, a.type, "args")) });
+      const props: AggregateProps = strip(
+        {
+          ...q,
+          orReplace: node.orReplace || undefined,
+          args: node.args.map(arg),
+          orderBy: node.orderBy?.map(arg),
+          options: definitionValues(ctx, node.options, "options"),
+          comment,
+          ddl,
+          source,
+        },
+        ["args"],
+      );
+      return make(POSTGRES_ENTITY_TYPES.aggregate, q, props);
+    }
+    case "collation": {
+      const q = qualified(ctx, node.name);
+      const comment = applyComments(tag, ctx, comments, q, ["COLLATION"]);
+      const props: CollationProps = stripUnset({ ...q, ifNotExists: node.ifNotExists || undefined, options: definitionValues(ctx, node.options, "options"), comment, ddl, source });
+      return make(POSTGRES_ENTITY_TYPES.collation, q, props);
+    }
+    case "cast": {
+      const sourceType = req(text(ctx, node.source, "sourceType"));
+      const targetType = req(text(ctx, node.target, "targetType"));
+      const name = `(${sourceType} AS ${targetType})`;
+      const comment = applyComments(tag, ctx, comments, { name }, ["CAST"]);
+      const props: CastProps = stripUnset({
+        name,
+        sourceType,
+        targetType,
+        method: node.method,
+        function: node.function ? target(ctx, node.function) : undefined,
+        functionName: node.function ? targetName(ctx, node.function) : undefined,
+        functionArgs: node.functionArgs ? text(ctx, node.functionArgs, "functionArgs") : undefined,
+        context: node.context,
+        comment,
+        ddl,
+        source,
+      });
+      return make(POSTGRES_ENTITY_TYPES.cast, { name }, props, undefined, name);
+    }
+    case "eventTrigger": {
+      const name = node.name.pieces[0] || identValue(req(text(ctx, node.name.span)));
+      feed(ctx, node.name.span, "name");
+      const comment = applyComments(tag, ctx, comments, { name }, ["EVENT TRIGGER"]);
+      const tags = node.filters.flatMap((f) => f.values.map((v) => req(stringValue(text(ctx, v, "tags")))));
+      const props: EventTriggerProps = strip(
+        {
+          name,
+          event: node.event.name || identValue(req(text(ctx, node.event.span, "event"))),
+          tags: tags.length > 0 ? tags : undefined,
+          function: target(ctx, node.function),
+          functionName: targetName(ctx, node.function),
+          comment,
+          ddl,
+          source,
+        },
+        [],
+      );
+      return make(POSTGRES_ENTITY_TYPES.eventTrigger, { name }, props);
+    }
     case "domain": {
       const q = qualified(ctx, node.name);
       const checks = node.checks.map((c) => stripUnset({ name: c.name, expr: req(text(ctx, c.expr, "checks")), notValid: c.notValid }) as CheckDef);
@@ -1644,9 +1898,13 @@ export function sequence(strings: TemplateStringsArray, ...values: unknown[]): P
   return build("sequence", strings, values) as PostgresSequence;
 }
 
-/** `` type`CREATE TYPE name AS ENUM (...)` ``: one enum type. */
-export function type(strings: TemplateStringsArray, ...values: unknown[]): PostgresEnum {
-  return build("type", strings, values) as PostgresEnum;
+/**
+ * `` type`CREATE TYPE name AS ENUM (...)` ``: one enum type; `AS (attribute
+ * type, ...)` a composite type, `AS RANGE (SUBTYPE = ...)` a range type (and
+ * its multirange type, which Postgres creates with it).
+ */
+export function type(strings: TemplateStringsArray, ...values: unknown[]): PostgresType {
+  return build("type", strings, values) as PostgresType;
 }
 
 /** `` domain`CREATE DOMAIN ...` ``: one domain. */
@@ -1673,6 +1931,36 @@ export function procedure(strings: TemplateStringsArray, ...values: unknown[]):
   return build("procedure", strings, values) as PostgresProcedure;
 }
 
+/**
+ * `` aggregate`CREATE [OR REPLACE] AGGREGATE name(argtype, ...) (SFUNC = ..., STYPE = ...)` ``:
+ * one aggregate, identified, as a function is, by its argument types.
+ */
+export function aggregate(strings: TemplateStringsArray, ...values: unknown[]): PostgresAggregate {
+  return build("aggregate", strings, values) as PostgresAggregate;
+}
+
+/** `` collation`CREATE COLLATION name (provider = icu, locale = '...')` ``: one collation. */
+export function collation(strings: TemplateStringsArray, ...values: unknown[]): PostgresCollation {
+  return build("collation", strings, values) as PostgresCollation;
+}
+
+/**
+ * `` cast`CREATE CAST (source AS target) WITH FUNCTION ${fn}(source) [AS ASSIGNMENT | AS IMPLICIT]` ``:
+ * one cast, named by its two types. Creating one takes owning the source or
+ * the target type.
+ */
+export function cast(strings: TemplateStringsArray, ...values: unknown[]): PostgresCast {
+  return build("cast", strings, values) as PostgresCast;
+}
+
+/**
+ * `` eventTrigger`CREATE EVENT TRIGGER name ON ddl_command_end WHEN TAG IN ('CREATE TABLE') EXECUTE FUNCTION ${fn}()` ``:
+ * one event trigger, the database's (no schema). Creating one takes a superuser.
+ */
+export function eventTrigger(strings: TemplateStringsArray, ...values: unknown[]): PostgresEventTrigger {
+  return build("eventTrigger", strings, values) as PostgresEventTrigger;
+}
+
 /** `` trigger`CREATE [OR REPLACE] [CONSTRAINT] TRIGGER name ... ON ${table} ... EXECUTE FUNCTION ${fn}()` ``: one trigger on its table. */
 export function trigger(strings: TemplateStringsArray, ...values: unknown[]): PostgresTrigger {
   return build("trigger", strings, values) as PostgresTrigger;

package/src/postgres/entity-types.ts

@@ -11,7 +11,13 @@ export const POSTGRES_ENTITY_TYPES = {
   materializedView: "Postgres::MaterializedView",
   sequence: "Postgres::Sequence",
   enum: "Postgres::Enum",
+  composite: "Postgres::CompositeType",
+  range: "Postgres::RangeType",
   domain: "Postgres::Domain",
+  aggregate: "Postgres::Aggregate",
+  collation: "Postgres::Collation",
+  cast: "Postgres::Cast",
+  eventTrigger: "Postgres::EventTrigger",
   extension: "Postgres::Extension",
   function: "Postgres::Function",
   procedure: "Postgres::Procedure",

package/src/postgres/import/generator.ts

@@ -1,7 +1,8 @@
 /**
  * The import IR as TypeScript: one `schema.ts` holding every imported object
- * as a `schema`, `table`, `index`, `view`, `sequence`, `type`, `domain` or
- * `extension` declaration, in dependency order, with the references between
+ * as a `schema`, `table`, `index`, `view`, `sequence`, `type`, `domain`,
+ * `extension`, `func`, `aggregate`, `collation`, `cast`, `eventTrigger` (and
+ * the rest of the tags) declaration, in dependency order, with the references between
  * them interpolated, so the build orders them as the server did:
  *
  * - a qualified name of another imported object becomes `${export}`
@@ -52,7 +53,13 @@ const TAG: Record<string, string> = {
   [POSTGRES_ENTITY_TYPES.materializedView]: "view",
   [POSTGRES_ENTITY_TYPES.sequence]: "sequence",
   [POSTGRES_ENTITY_TYPES.enum]: "type",
+  [POSTGRES_ENTITY_TYPES.composite]: "type",
+  [POSTGRES_ENTITY_TYPES.range]: "type",
   [POSTGRES_ENTITY_TYPES.domain]: "domain",
+  [POSTGRES_ENTITY_TYPES.aggregate]: "aggregate",
+  [POSTGRES_ENTITY_TYPES.collation]: "collation",
+  [POSTGRES_ENTITY_TYPES.cast]: "cast",
+  [POSTGRES_ENTITY_TYPES.eventTrigger]: "eventTrigger",
   [POSTGRES_ENTITY_TYPES.extension]: "extension",
   [POSTGRES_ENTITY_TYPES.function]: "func",
   [POSTGRES_ENTITY_TYPES.procedure]: "procedure",
@@ -63,6 +70,19 @@ const TAG: Record<string, string> = {
   [POSTGRES_ENTITY_TYPES.defaultPrivileges]: "grant",
 };
 
+/** The kinds no other object's DDL names. */
+const UNREFERENCED: ReadonlySet<string> = new Set([
+  POSTGRES_ENTITY_TYPES.index,
+  POSTGRES_ENTITY_TYPES.trigger,
+  POSTGRES_ENTITY_TYPES.policy,
+  POSTGRES_ENTITY_TYPES.grant,
+  POSTGRES_ENTITY_TYPES.defaultPrivileges,
+  POSTGRES_ENTITY_TYPES.role,
+  POSTGRES_ENTITY_TYPES.extension,
+  POSTGRES_ENTITY_TYPES.cast,
+  POSTGRES_ENTITY_TYPES.eventTrigger,
+]);
+
 /** The tag each entity type is declared with (`table`, `func`, ...). */
 export const POSTGRES_TAG_OF: Readonly<Record<string, string>> = TAG;
 
@@ -104,6 +124,13 @@ function bareSpots(tokens: Token[]): Set<number> {
   for (const node of nodes) {
     if (node.statement === "table") for (const c of node.columns) if (c.type) first(c.type.from, c.type.to);
     if (node.statement === "domain") first(node.type.from, node.type.to);
+    if (node.statement === "composite") for (const a of node.attributes) first(a.type.from, a.type.to);
+    if (node.statement === "cast") {
+      first(node.source.from, node.source.to);
+      first(node.target.from, node.target.to);
+      name(node.function);
+    }
+    if (node.statement === "eventTrigger") name(node.function);
     if (node.statement === "index" || node.statement === "policy") name(node.table);
     if (node.statement === "trigger") {
       name(node.table);
@@ -202,8 +229,8 @@ export function postgresTemplates(items: readonly Item[], targets: readonly Item
   const schemaExport = new Map<string, string>();
   for (const it of targets) {
     if (it.type === POSTGRES_ENTITY_TYPES.schema) schemaExport.set(it.name, it.exportName);
-    // An index or a trigger is never referenced by name in another object's DDL.
-    else if (it.type !== POSTGRES_ENTITY_TYPES.index && it.type !== POSTGRES_ENTITY_TYPES.trigger && it.type !== POSTGRES_ENTITY_TYPES.policy && it.type !== POSTGRES_ENTITY_TYPES.grant && it.type !== POSTGRES_ENTITY_TYPES.defaultPrivileges && it.type !== POSTGRES_ENTITY_TYPES.role && it.type !== POSTGRES_ENTITY_TYPES.extension) {
+    // An index, a trigger, a cast or an event trigger is never referenced by name in another object's DDL.
+    else if (!UNREFERENCED.has(it.type)) {
       byQualified.set(it.schema ? `${it.schema}.${it.name}` : it.name, it);
     }
   }

package/src/postgres/import/live-export.ts

@@ -17,6 +17,12 @@
  *   declarations: the GRANT and REVOKE statements that take a new object's
  *   privileges to what the server holds. Roles are the environment's and are
  *   not imported.
+ * - An object of a kind no declaration holds (an aggregate, a cast, a
+ *   composite type, an event trigger, ...; `../live/undeclarable.ts`) fails
+ *   the import, which names every one of them (#3911). `skipUndeclarable`
+ *   (`--skip-undeclarable`) imports the rest and lists them as warnings. A
+ *   selector or `owned` import asks for objects chant can hold, so it does
+ *   not look.
  */
 
 import type { ExportedTemplate, ResourceSelector } from "@intentius/chant/lexicon";
@@ -25,6 +31,9 @@ import { markProviderOwned, readLiveSchema } from "../live/catalog";
 import { objectsToIR, type ImportedPgObject } from "./ir";
 import { isChantManaged } from "../../core/ownership";
 import { importedAccess } from "../access/import";
+import { readUndeclarable } from "../live/undeclarable";
+import { describeUndeclarable, refuseUndeclarable, type UndeclarableObject } from "../../core/undeclarable";
+import { isProviderOwned, providerData } from "../providers";
 
 export interface ExportOptions extends Omit<BindOptions, "environment"> {
   environment: string;
@@ -33,20 +42,33 @@ export interface ExportOptions extends Omit<BindOptions, "environment"> {
   selector?: ResourceSelector;
   owned?: boolean;
   verbatim?: boolean;
+  /** Import what can be declared, and list the objects of kinds no declaration holds as warnings instead of failing (#3911). */
+  skipUndeclarable?: boolean;
 }
 
 export async function exportResources(options: ExportOptions): Promise<ExportedTemplate> {
   const { target, client } = await bindPostgres(options);
   let live;
   let access: ImportedPgObject[] = [];
+  // A selector or an owned import asks only for what chant can hold.
+  const checked = !options.selector && !options.owned;
+  let undeclarable: { objects: UndeclarableObject[]; unread: string[] } = { objects: [], unread: [] };
   try {
+    if (checked) undeclarable = await readUndeclarable(client, { schemas: target.schemas });
     live = markProviderOwned(await readLiveSchema(client, { schemas: target.schemas, access: target.access === true }), target.provider);
     // Where the profile manages access, the privileges on what is imported, and the default privileges, as grant declarations.
     if (target.access === true && !options.selector) access = await importedAccess(client, live.filter((o) => !o.foreign && !o.unsupported && (!options.owned || isChantManaged(o.comment))), target.schemas);
   } finally {
     await client.end();
   }
-  const warnings: string[] = [];
+  const warnings: string[] = undeclarable.unread.map((u) => `the server was not checked for objects of one kind chant cannot declare, so some may be left out: ${u}`);
+  // A managed provider's own (in its schemas, or owned by its roles) is the provider's, as for the objects read below.
+  const provider = target.provider;
+  const providers = (o: UndeclarableObject) =>
+    provider !== undefined &&
+    ((o.schema !== undefined && isProviderOwned(provider, { kind: "schema", name: o.schema })) || (o.owner !== undefined && isProviderOwned(provider, { kind: "role", name: o.owner })));
+  for (const o of undeclarable.objects.filter(providers)) warnings.push(`${describeUndeclarable(o)} is kept by ${providerData(provider!).label}; left out`);
+  refuseUndeclarable("postgres", undeclarable.objects.filter((o) => !providers(o)), options.skipUndeclarable, warnings);
   const objects: ImportedPgObject[] = [];
   for (const o of live) {
     if (options.owned && !isChantManaged(o.comment)) continue;
@@ -54,7 +76,8 @@ export async function exportResources(options: ExportOptions): Promise<ExportedT
     const name = options.selector?.name;
     if (name !== undefined && name !== o.name && name !== `${o.schema}.${o.name}`) continue;
     if (o.unsupported) {
-      warnings.push(`${o.schema ? `${o.schema}.` : ""}${o.name}${o.signature ?? ""} is left out: ${o.unsupported}`);
+      // When checked, it is among the undeclarable objects above.
+      if (!checked) warnings.push(`${o.schema ? `${o.schema}.` : ""}${o.name}${o.signature ?? ""} is left out: ${o.unsupported}`);
       continue;
     }
     if (o.foreign) {