@distrohelena/canton-typescript-sdk 0.1.36 → 0.1.37

package/dist/query/pqs/pqs-sql-compiler.js

@@ -1,363 +1,412 @@
-import { assertQueryPageArgs, } from "../model-types.js";
-import { PqsSchemaProfileV1 } from "./pqs-schema-profile.js";
 import { pqsRelationEdges, pqsRelationMetadata } from "./pqs-schema-profile.js";
-export function compileContractFindMany(args, profile) {
-    assertQueryPageArgs(args);
+import { quotePqsIdentifier, quotePqsString } from "./pqs-sql-syntax.js";
+import { compilePqsResultShape } from "./pqs-result-shape.js";
+import { compileCanonicalPublicNumericIdentityPartsSql, compileCanonicalPublicNumericIdentitySql } from "../canonical/public-identity.js";
+export function compileCanonicalPhysicalField(relation, field, alias, profile) {
+    const column = pqsRelationMetadata[relation].fields[field];
+    if (column === undefined)
+        throw new Error(`${field} is not a field of ${relation}`);
+    const physical = qualified(alias, column);
+    if (relation === "__events" && field === "eventId") {
+        return eventIdExpression(physical);
+    }
+    if (relation === "__events" && field === "pk") {
+        return compileCanonicalPublicNumericIdentitySql(eventIdExpression(qualified(alias, "event_id")));
+    }
+    if (relation === "__events" && field === "txIx") {
+        return transactionOffsetExpression(profile, physical);
+    }
+    if (relation === "__events" && field === "type") {
+        return `case ${physical}::text when 'create' then 'created' when 'exercise' then 'exercised' else ${physical}::text end`;
+    }
+    if (relation === "__transactions" && field === "workflowId") {
+        return `nullif(${physical}, '')`;
+    }
+    if (relation === "__transactions" && field === "traceContext") {
+        return `case when ${physical} is null then null else jsonb_strip_nulls(jsonb_build_object('traceparent', nullif(to_jsonb(${physical})->>'trace_parent', ''), 'tracestate', nullif(to_jsonb(${physical})->>'trace_state', ''))) end`;
+    }
+    if ((relation === "__transactions" || relation === "__watermark") && (field === "ix" || field === "offset")) {
+        return qualified(alias, "offset");
+    }
+    if (relation === "__packages" && field === "pk") {
+        return compileCanonicalPublicNumericIdentitySql(qualified(alias, "id"));
+    }
+    if (relation === "__contract_tpe" && field === "pk") {
+        return compileCanonicalPublicNumericIdentitySql(compileCanonicalPublicNumericIdentityPartsSql([qualified(alias, "payload_type"), qualified(alias, "template_fqn")]));
+    }
+    if (relation === "__exercise_tpe" && field === "pk") {
+        return compileCanonicalPublicNumericIdentitySql(qualified(alias, "choice_fqn"));
+    }
+    if (relation === "__exercises" && field === "tpePk") {
+        return exerciseTypePublicKeyExpression(profile, physical);
+    }
+    if (relation === "__exercises" && field === "contractTpePk") {
+        return contractTypePublicKeyExpression(profile, physical);
+    }
+    if (relation === "__exercises" && field === "exerciseEventPk") {
+        return eventPublicKeyExpression(profile, physical);
+    }
+    if (relation === "__exercises" && field === "exercisedAtIx") {
+        return transactionOffsetExpression(profile, physical);
+    }
+    if (relation === "__exercises" && field === "packagePk") {
+        return packagePublicKeyExpression(profile, physical);
+    }
+    return physical;
+}
+function eventIdExpression(physical) {
+    return `(to_jsonb(${physical})->>'offset') || ':' || (to_jsonb(${physical})->>'node_id')`;
+}
+function transactionOffsetExpression(profile, physicalIx) {
+    return `(select "canonical_transaction"."offset" from ${profile.relation("__transactions")} "canonical_transaction" where "canonical_transaction"."ix" = ${physicalIx})`;
+}
+function eventPublicKeyExpression(profile, physicalPk) {
+    const eventId = eventIdExpression('"canonical_event"."event_id"');
+    return `(select ${compileCanonicalPublicNumericIdentitySql(eventId)} from ${profile.relation("__events")} "canonical_event" where "canonical_event"."pk" = ${physicalPk})`;
+}
+function packagePublicKeyExpression(profile, physicalPk) {
+    return `(select ${compileCanonicalPublicNumericIdentitySql('"canonical_package"."id"')} from ${profile.relation("__packages")} "canonical_package" where "canonical_package"."pk" = ${physicalPk})`;
+}
+function contractTypePublicKeyExpression(profile, physicalPk) {
+    const identity = compileCanonicalPublicNumericIdentityPartsSql(['"canonical_contract_type"."payload_type"', '"canonical_contract_type"."template_fqn"']);
+    return `(select ${compileCanonicalPublicNumericIdentitySql(identity)} from ${profile.relation("__contract_tpe")} "canonical_contract_type" where "canonical_contract_type"."pk" = ${physicalPk})`;
+}
+function exerciseTypePublicKeyExpression(profile, physicalPk) {
+    return `(select ${compileCanonicalPublicNumericIdentitySql('"canonical_exercise_type"."choice_fqn"')} from ${profile.relation("__exercise_tpe")} "canonical_exercise_type" where "canonical_exercise_type"."pk" = ${physicalPk})`;
+}
+export function compileContractFindMany(query, profile) {
+    if (query.relation !== "contracts")
+        throw new Error("compileContractFindMany requires a contracts query");
     const values = [];
     const addValue = (value) => {
         values.push(value);
         return `$${values.length}`;
     };
     const conditions = [];
-    const where = args.where === undefined ? undefined : compileWhere(args.where, addValue, profile);
+    const where = query.predicate === undefined ? undefined : compileCanonicalContractPredicate(query.predicate, addValue, profile, "contract_row");
     if (where !== undefined)
         conditions.push(where);
-    if (args.parties !== undefined) {
-        conditions.push(`contract_row.witnesses && ${addValue(args.parties)}::text[]`);
+    if (query.parties !== undefined) {
+        conditions.push(`contract_row.witnesses && ${addValue(query.parties)}::text[]`);
     }
-    const orderBy = compileOrderBy(args.orderBy);
+    const orderBy = compileCanonicalContractOrderBy(query.orderBy);
     const whereSql = conditions.length === 0 ? "" : `where ${conditions.join(" and ")}`;
-    const limitSql = args.take === undefined ? "" : `limit ${addValue(args.take)}`;
-    const offsetSql = args.skip === undefined ? "" : `offset ${addValue(args.skip)}`;
-    const included = compileProfileIncludes("__contracts", "contract_row", args.include, profile, addValue);
-    const jsonProjection = Object.entries(args.select?.json ?? {}).map(([name, projection]) => {
-        if (projection.field !== "payload")
-            throw new Error(`${projection.field} is not a JSON field of contracts`);
-        if (projection.path.length === 0 || projection.path.some((segment) => segment.length === 0))
-            throw new Error(`${name}.path must be a non-empty JSON path`);
+    const limitSql = query.take === undefined ? "" : `limit ${addValue(query.take)}`;
+    const offsetSql = query.skip === 0 ? "" : `offset ${addValue(query.skip)}`;
+    const included = compileCanonicalPhysicalIncludes("__contracts", "contract_row", query.includes, profile, addValue);
+    const jsonProjection = (query.select?.json ?? []).map((projection) => {
         const text = `contract_row.payload #>> ${addValue(projection.path)}::text[]`;
         const expression = projection.as === "text" ? text : projection.as === "numeric" ? `(${text})::numeric::text` : projection.as === "boolean" ? `(${text})::boolean` : `(${text})::timestamptz`;
-        return `${expression} as "${name}"`;
+        return `${expression} as ${quotePqsIdentifier(projection.name)}`;
     });
     return {
         text: `select
   contract_row.contract_id as contract_id,
-  contract_row.creation_package_id as package_id,
+  ${contractPackageIdExpression("contract_row", profile)} as package_id,
   contract_row.payload,
   contract_row.witnesses,
-  contract_row.created_at_ix::text as created_event_offset,
+  created_tx.offset::text as created_event_offset,
   created_tx.effective_at as created_at,
-  contract_row.archived_at_ix::text as archived_event_offset,
+  archived_tx.offset::text as archived_event_offset,
   archived_tx.effective_at as archived_at,
   contract_row.archived_at_ix is null as active,
-  contract_row.creation_package_id as template_package_id,
+  ${contractPackageIdExpression("contract_row", profile)} as template_package_id,
   contract_tpe_row.module_name as template_module_name,
-  contract_tpe_row.entity_name as template_entity_name${[...included, ...jsonProjection].length === 0 ? "" : `,\n  ${[...included, ...jsonProjection].join(",\n  ")}`}
+  contract_tpe_row.entity_name as template_entity_name${[...included.map((include) => include.selection), ...jsonProjection].length === 0 ? "" : `,\n  ${[...included.map((include) => include.selection), ...jsonProjection].join(",\n  ")}`}
 from ${profile.relation("__contracts")} contract_row
 join ${profile.relation("__contract_tpe")} contract_tpe_row on contract_tpe_row.pk = contract_row.tpe_pk
 left join ${profile.relation("__transactions")} created_tx on created_tx.ix = contract_row.created_at_ix
 left join ${profile.relation("__transactions")} archived_tx on archived_tx.ix = contract_row.archived_at_ix
+left join ${profile.relation("__packages")} contract_package on contract_package.pk = contract_row.package_pk
 ${whereSql}
 ${orderBy}
 ${limitSql}
 ${offsetSql}`,
         values,
+        resultShape: compilePqsResultShape("__contracts", "many", query.select, query.includes),
     };
 }
-function compileProfileIncludes(source, parentAlias, include, profile, addValue) {
+export function compileContractCount(query, profile) {
+    if (query.relation !== "contracts")
+        throw new Error("compileContractCount requires a contracts query");
+    const values = [];
+    const add = (value) => { values.push(value); return `$${values.length}`; };
+    const where = compileContractWhere(query.predicate, query.parties, profile, add);
+    return { text: `select count(*)::text as count ${contractFrom(profile)}${where}`, values };
+}
+export function compileContractAggregate(query, profile) {
+    if (query.relation !== "contracts")
+        throw new Error("compileContractAggregate requires a contracts query");
+    const values = [];
+    const add = (value) => { values.push(value); return `$${values.length}`; };
     const selected = [];
-    for (const [name, option] of Object.entries(include ?? {})) {
-        const edge = pqsRelationEdges[source]?.[name];
-        if (edge === undefined)
-            throw new Error(`${name} is not a relation of ${source}`);
-        const settings = option === true ? {} : option;
-        if (settings === null || typeof settings !== "object" || Array.isArray(settings))
-            throw new Error(`${name} must be an include option`);
-        const options = settings;
-        if (edge.cardinality === "many" && (typeof options.take !== "number" || !Number.isInteger(options.take) || options.take < 0))
-            throw new Error(`${name} is a to-many relation and requires a non-negative take`);
-        const alias = `"${name}"`;
-        const nested = compileProfileIncludes(edge.target, alias, options.include, profile, addValue);
-        const metadata = pqsRelationMetadata[edge.target];
-        const requested = compileIncludedFields(edge.target, options.select, alias, profile);
-        const json = options.select?.json ?? {};
-        const jsonSelections = Object.entries(json).map(([projectionName, projection]) => {
-            if (!PqsSchemaProfileV1.jsonField(edge.target, projection.field))
-                throw new Error(`${projection.field} is not a JSON field of ${edge.target}`);
-            if (projection.path.length === 0 || projection.path.some((segment) => segment.length === 0))
-                throw new Error(`${projectionName}.path must be a non-empty JSON path`);
-            const column = edge.target === "__contracts"
-                ? projection.field === "payload" ? "payload" : undefined
-                : metadata.fields[projection.field];
-            if (column === undefined)
-                throw new Error(`${projection.field} is not a field of ${edge.target}`);
-            const text = `${alias}."${column}" #>> ${addValue(projection.path)}::text[]`;
+    if (query.aggregates.count)
+        selected.push("count(*)::text as count");
+    const fields = { createdEventOffset: "created_tx.offset", archivedEventOffset: "archived_tx.offset" };
+    for (const [operation, requested] of [["min", query.aggregates.min], ["max", query.aggregates.max], ["sum", query.aggregates.sum]]) {
+        for (const field of requested) {
+            const expression = fields[field];
+            if (expression === undefined)
+                throw new Error(`${field} is not a numeric aggregate field of contracts`);
+            selected.push(`${operation}(${expression})::text as ${quotePqsIdentifier(`${operation}_${field}`)}`);
+        }
+    }
+    if (selected.length === 0)
+        throw new Error("aggregate must request at least one result");
+    return { text: `select ${selected.join(", ")} ${contractFrom(profile)}${compileContractWhere(query.predicate, undefined, profile, add)}`, values };
+}
+function contractFrom(profile) {
+    return `from ${profile.relation("__contracts")} contract_row join ${profile.relation("__contract_tpe")} contract_tpe_row on contract_tpe_row.pk = contract_row.tpe_pk left join ${profile.relation("__transactions")} created_tx on created_tx.ix = contract_row.created_at_ix left join ${profile.relation("__transactions")} archived_tx on archived_tx.ix = contract_row.archived_at_ix left join ${profile.relation("__packages")} contract_package on contract_package.pk = contract_row.package_pk`;
+}
+function compileContractWhere(predicate, parties, profile, add) {
+    const conditions = [
+        ...(predicate === undefined ? [] : [compileCanonicalContractPredicate(predicate, add, profile, "contract_row")]),
+        ...(parties === undefined ? [] : [`contract_row.witnesses && ${add(parties)}::text[]`]),
+    ];
+    return conditions.length === 0 ? "" : ` where ${conditions.join(" and ")}`;
+}
+export function compileCanonicalPhysicalIncludes(source, parentAlias, includes, profile, add) {
+    return includes.map((include) => {
+        const edge = pqsRelationEdges[source]?.[include.edge];
+        if (edge === undefined || edge.target !== pqsRelation(include.relation))
+            throw new Error(`Invalid canonical include ${include.edge}`);
+        const alias = quotePqsIdentifier(include.edge);
+        const fields = compileCanonicalIncludedFields(edge.target, include.select, alias, profile);
+        const json = (include.select?.json ?? []).flatMap((projection) => {
+            const base = edge.target === "__contracts"
+                ? projection.field === "payload" ? `${alias}."payload"` : undefined
+                : pqsRelationMetadata[edge.target].fields[projection.field] === undefined ? undefined : compileCanonicalPhysicalField(edge.target, projection.field, alias, profile);
+            if (base === undefined)
+                throw new Error(`Invalid canonical JSON projection ${projection.field}`);
+            const text = `${base} #>> ${add(projection.path)}::text[]`;
             const expression = projection.as === "text" ? text : projection.as === "numeric" ? `(${text})::numeric::text` : projection.as === "boolean" ? `(${text})::boolean` : `(${text})::timestamptz`;
-            return [`'${projectionName}'`, expression];
+            return [quotePqsString(projection.name), expression];
         });
-        if (requested.length === 0 && jsonSelections.length === 0)
-            throw new Error(`Nested ${name}.select must include at least one field`);
-        const fields = requested.flatMap(([field, expression]) => [`'${field}'`, expression]);
-        const nestedFields = nested.flatMap((selection) => {
-            const match = /^(.*) as "([^"]+)"$/.exec(selection);
-            return match === null ? [] : [`'${match[2]}'`, match[1]];
-        });
-        const object = `jsonb_build_object(${[...fields, ...jsonSelections.flat(), ...nestedFields].join(", ")})`;
-        const relationFilter = options.where === undefined ? "true" : compilePhysicalWhere(edge.target, options.where, alias, profile, addValue);
-        const condition = `${alias}."${edge.targetColumn}" = ${parentAlias}."${edge.sourceColumn}" and (${relationFilter})`;
-        const orderBy = compilePhysicalOrderBy(edge.target, options.orderBy, alias);
-        const expression = edge.cardinality === "one"
+        const nested = compileCanonicalPhysicalIncludes(edge.target, alias, include.includes, profile, add);
+        const nestedFields = nested.flatMap((selection) => [quotePqsString(selection.key), selection.expression]);
+        const object = `jsonb_build_object(${[...fields.flatMap(([field, expression]) => [`'${field}'`, expression]), ...json.flat(), ...nestedFields].join(", ")})`;
+        const filter = include.predicate === undefined ? "true" : compileCanonicalPhysicalPredicate(edge.target, include.predicate, alias, profile, add);
+        const condition = `${compileCanonicalPhysicalEdgeJoin(source, include.edge, parentAlias, alias, profile)} and (${filter})`;
+        const orderBy = compileCanonicalPhysicalOrderBy(edge.target, include.orderBy, alias, profile);
+        const limit = include.cardinality === "many" ? ` limit ${add(include.take)}` : "";
+        const offset = include.cardinality === "many" && include.skip > 0 ? ` offset ${add(include.skip)}` : "";
+        const expression = include.cardinality === "one"
             ? `(select ${object} from ${profile.relation(edge.target)} ${alias} where ${condition})`
-            : `(select coalesce(jsonb_agg("${name}_limited".value), '[]'::jsonb) from (select ${object} as value from ${profile.relation(edge.target)} ${alias} where ${condition}${orderBy} limit ${addValue(options.take)}) "${name}_limited")`;
-        selected.push(`${expression} as "${name}"`);
-    }
-    return selected;
+            : `(select coalesce(jsonb_agg("${include.edge}_limited".value), '[]'::jsonb) from (select ${object} as value from ${profile.relation(edge.target)} ${alias} where ${condition}${orderBy}${limit}${offset}) "${include.edge}_limited")`;
+        return { key: include.edge, expression, selection: `${expression} as ${quotePqsIdentifier(include.edge)}` };
+    });
 }
-function compileIncludedFields(target, select, alias, profile) {
+function compileCanonicalIncludedFields(target, select, alias, profile) {
     if (target !== "__contracts") {
         const metadata = pqsRelationMetadata[target];
-        const selected = select === undefined
-            ? Object.entries(metadata.fields)
-            : Object.entries(select).filter(([field, enabled]) => field !== "json" && enabled === true).map(([field]) => [field, metadata.fields[field]]);
-        if (selected.some(([, column]) => column === undefined))
-            throw new Error("Nested relation.select references an unknown field");
-        return selected.map(([field, column]) => [field, `${alias}."${column}"`]);
+        const fields = select === undefined ? Object.keys(metadata.fields) : select.fields;
+        return fields.map((field) => {
+            const expression = compileCanonicalPhysicalField(target, field, alias, profile);
+            return [field, metadata.numericFields.includes(field) ? `${expression}::text` : expression];
+        });
     }
-    const selected = select === undefined
-        ? ["contractId", "templateId", "packageId", "payload", "witnesses", "createdEventOffset", "createdAt", "archivedEventOffset", "archivedAt", "active"]
-        : Object.entries(select).filter(([field, enabled]) => field !== "json" && enabled === true).map(([field]) => field);
+    const fields = select === undefined ? ["contractId", "templateId", "packageId", "payload", "witnesses", "createdEventOffset", "createdAt", "archivedEventOffset", "archivedAt", "active"] : select.fields;
     const expressions = {
-        contractId: `${alias}."contract_id"`,
-        templateId: `jsonb_build_object('packageId', ${alias}."creation_package_id", 'moduleName', (select contract_type."module_name" from ${profile.relation("__contract_tpe")} contract_type where contract_type."pk" = ${alias}."tpe_pk"), 'entityName', (select contract_type."entity_name" from ${profile.relation("__contract_tpe")} contract_type where contract_type."pk" = ${alias}."tpe_pk"))`,
-        packageId: `${alias}."creation_package_id"`,
-        payload: `${alias}."payload"`,
-        witnesses: `${alias}."witnesses"`,
-        createdEventOffset: `${alias}."created_at_ix"::text`,
-        createdAt: `(select created_transaction."effective_at" from ${profile.relation("__transactions")} created_transaction where created_transaction."ix" = ${alias}."created_at_ix")`,
-        archivedEventOffset: `${alias}."archived_at_ix"::text`,
-        archivedAt: `(select archived_transaction."effective_at" from ${profile.relation("__transactions")} archived_transaction where archived_transaction."ix" = ${alias}."archived_at_ix")`,
-        active: `${alias}."archived_at_ix" is null`,
+        contractId: `${alias}."contract_id"`, templateId: `jsonb_build_object('packageId', ${contractPackageIdExpression(alias, profile)}, 'moduleName', ${contractTypeFieldExpression(alias, "module_name", profile)}, 'entityName', ${contractTypeFieldExpression(alias, "entity_name", profile)})`, packageId: contractPackageIdExpression(alias, profile), payload: `${alias}."payload"`, witnesses: `${alias}."witnesses"`, createdEventOffset: `${contractTransactionFieldExpression(alias, "created", "offset", profile)}::text`, createdAt: contractTransactionFieldExpression(alias, "created", "effective_at", profile), archivedEventOffset: `${contractTransactionFieldExpression(alias, "archived", "offset", profile)}::text`, archivedAt: contractTransactionFieldExpression(alias, "archived", "effective_at", profile), active: `${alias}."archived_at_ix" is null`,
     };
-    const requested = selected.map((field) => [field, expressions[field]]);
-    if (requested.some(([, expression]) => expression === undefined))
-        throw new Error("Nested contract.select references an unknown field");
-    return requested;
+    return fields.map((field) => [field, expressions[field]]);
+}
+function compileCanonicalContractPredicate(predicate, add, profile, alias) {
+    return compileCanonicalPredicate("__contracts", predicate, alias, profile, add, true);
+}
+export function compileCanonicalPhysicalPredicate(relation, predicate, alias, profile, add) {
+    return compileCanonicalPredicate(relation, predicate, alias, profile, add, relation === "__contracts");
+}
+function compileCanonicalPredicate(relation, predicate, alias, profile, add, logicalContracts) {
+    if (predicate.kind === "and" || predicate.kind === "or")
+        return predicate.children.length === 0 ? predicate.kind === "and" ? "true" : "false" : `(${predicate.children.map((child) => compileCanonicalPredicate(relation, child, alias, profile, add, logicalContracts)).join(` ${predicate.kind} `)})`;
+    if (predicate.kind === "not")
+        return `not (${compileCanonicalPredicate(relation, predicate.child, alias, profile, add, logicalContracts)})`;
+    if (predicate.kind === "relation") {
+        const edge = pqsRelationEdges[relation]?.[predicate.edge];
+        if (edge === undefined)
+            throw new Error(`Invalid canonical edge ${predicate.edge}`);
+        const relatedAlias = `"${predicate.edge}"`;
+        const join = compileCanonicalPhysicalEdgeJoin(relation, predicate.edge, alias, relatedAlias, profile);
+        const condition = compileCanonicalPredicate(edge.target, predicate.predicate, relatedAlias, profile, add, edge.target === "__contracts");
+        const base = `select 1 from ${profile.relation(edge.target)} ${relatedAlias} where ${join} and (${condition})`;
+        return predicate.quantifier === "one" || predicate.quantifier === "some" ? `exists (${base})` : predicate.quantifier === "none" ? `not exists (${base})` : `not exists (select 1 from ${profile.relation(edge.target)} ${relatedAlias} where ${join} and not (${condition}))`;
+    }
+    if (predicate.kind !== "scalar")
+        throw new Error("Unknown canonical predicate");
+    const [field, ...path] = predicate.path;
+    if (logicalContracts && field === "active")
+        return `${logicalQualified(alias, "archived_at_ix")} is ${predicate.value === true ? "null" : "not null"}`;
+    if (logicalContracts && field === "witnesses")
+        return `${add(predicate.value)} = any(${logicalQualified(alias, "witnesses")})`;
+    const column = logicalContracts ? undefined : pqsRelationMetadata[relation].fields[field];
+    if (!logicalContracts && column === undefined)
+        throw new Error(`${field} is not a field of ${relation}`);
+    const canonicalExpression = logicalContracts
+        ? contractPredicateExpression(alias, field, path, profile, add)
+        : path.length > 0
+            ? `${compileCanonicalPhysicalField(relation, field, alias, profile)} #>> ${add(path)}::text[]`
+            : compileCanonicalPhysicalField(relation, field, alias, profile);
+    const inverseEventType = relation === "__events" && field === "type" && (predicate.operator === "equals" || predicate.operator === "in");
+    const expression = inverseEventType ? qualified(alias, column) : canonicalExpression;
+    const value = inverseEventType ? physicalEventType(predicate.value) : predicate.value;
+    const sql = { equals: "=", lt: "<", lte: "<=", gt: ">", gte: ">=", like: "like", ilike: "ilike" }[predicate.operator];
+    if (predicate.operator === "is")
+        return `${expression} is null`;
+    if (predicate.operator === "isNot")
+        return `${expression} is not null`;
+    if (predicate.operator === "in")
+        return value.length === 0 ? "false" : `${expression} = any(${add(value)})`;
+    if (predicate.operator === "has")
+        return `${add(value)} = any(${qualified(alias, column)})`;
+    if (sql === undefined)
+        throw new Error(`Unsupported canonical operator ${predicate.operator}`);
+    return `${expression} ${sql} ${add(value)}`;
+}
+function compileCanonicalPhysicalEdgeJoin(source, edgeName, parentAlias, targetAlias, profile) {
+    const edge = pqsRelationEdges[source]?.[edgeName];
+    if (edge === undefined)
+        throw new Error(`Invalid canonical edge ${edgeName}`);
+    if (source === "__contract_tpe" && edgeName === "contracts") {
+        return `${contractTypePublicKeyExpression(profile, qualified(targetAlias, "tpe_pk"))} = ${compileCanonicalPhysicalField(source, "pk", parentAlias, profile)}`;
+    }
+    if (source === "__contract_tpe" && edgeName === "exercises") {
+        return `${compileCanonicalPhysicalField("__exercises", "contractTpePk", targetAlias, profile)} = ${compileCanonicalPhysicalField(source, "pk", parentAlias, profile)}`;
+    }
+    if (source === "__exercise_tpe" && edgeName === "exercises") {
+        return `${compileCanonicalPhysicalField("__exercises", "tpePk", targetAlias, profile)} = ${compileCanonicalPhysicalField(source, "pk", parentAlias, profile)}`;
+    }
+    const parent = parentAlias.length === 0
+        ? `${profile.relation(source)}."${edge.sourceColumn}"`
+        : qualified(parentAlias, edge.sourceColumn);
+    return `${targetAlias}."${edge.targetColumn}" = ${parent}`;
+}
+function contractPredicateExpression(alias, field, path, profile, add) {
+    if (field === "payload")
+        return `${logicalQualified(alias, "payload")} #>> ${add(path)}::text[]`;
+    if (field === "contractId")
+        return logicalQualified(alias, "contract_id");
+    if (field === "packageId")
+        return contractPackageIdExpression(alias, profile);
+    if (field === "createdEventOffset")
+        return contractTransactionFieldExpression(alias, "created", "offset", profile);
+    if (field === "createdAt")
+        return contractTransactionFieldExpression(alias, "created", "effective_at", profile);
+    if (field === "archivedEventOffset")
+        return contractTransactionFieldExpression(alias, "archived", "offset", profile);
+    if (field === "archivedAt")
+        return contractTransactionFieldExpression(alias, "archived", "effective_at", profile);
+    if (field === "templateId" && path[0] === "packageId")
+        return contractPackageIdExpression(alias, profile);
+    if (field === "templateId" && path[0] === "moduleName")
+        return contractTypeFieldExpression(alias, "module_name", profile);
+    if (field === "templateId" && path[0] === "entityName")
+        return contractTypeFieldExpression(alias, "entity_name", profile);
+    throw new Error(`${field} is not a field of contracts`);
+}
+function physicalEventType(value) {
+    if (Array.isArray(value))
+        return value.map(physicalEventType);
+    if (value === "created")
+        return "create";
+    if (value === "exercised")
+        return "exercise";
+    return value;
+}
+function qualified(alias, column) {
+    return alias.length === 0 ? `"${column}"` : `${alias}."${column}"`;
+}
+function logicalQualified(alias, column) {
+    return alias === "contract_row" ? `${alias}.${column}` : qualified(alias, column);
 }
-function compilePhysicalOrderBy(relation, orderBy, alias) {
-    if (orderBy === undefined)
-        return "";
-    if (!Array.isArray(orderBy) || orderBy.length === 0)
-        throw new Error("Nested orderBy must be a non-empty list");
-    const metadata = pqsRelationMetadata[relation];
-    const entries = orderBy.flatMap((entry) => entry !== null && typeof entry === "object" ? Object.entries(entry) : []);
-    if (entries.length !== orderBy.length || entries.some(([, direction]) => direction !== "asc" && direction !== "desc"))
-        throw new Error("Nested orderBy entries must have one valid direction");
-    return ` order by ${entries.map(([field, direction]) => {
-        const column = metadata.fields[field];
-        if (column === undefined)
-            throw new Error(`${field} is not a field of ${relation}`);
-        return `${alias}."${column}" ${direction}`;
-    }).join(", ")}`;
+function contractPackageIdExpression(alias, profile) {
+    const packageId = alias === "contract_row"
+        ? "contract_package.id"
+        : `(select contract_package."id" from ${profile.relation("__packages")} contract_package where contract_package."pk" = ${qualified(alias, "package_pk")})`;
+    return `coalesce(${logicalQualified(alias, "creation_package_id")}, ${packageId})`;
+}
+function contractTransactionFieldExpression(alias, lifecycle, field, profile) {
+    if (alias === "contract_row")
+        return `${lifecycle}_tx.${field}`;
+    const transaction = `${lifecycle}_transaction`;
+    return `(select ${transaction}."${field}" from ${profile.relation("__transactions")} ${transaction} where ${transaction}."ix" = ${qualified(alias, `${lifecycle}_at_ix`)})`;
+}
+function contractTypeFieldExpression(alias, field, profile) {
+    if (alias === "contract_row")
+        return `contract_tpe_row.${field}`;
+    return `(select contract_type."${field}" from ${profile.relation("__contract_tpe")} contract_type where contract_type."pk" = ${qualified(alias, "tpe_pk")})`;
+}
+function compileCanonicalContractOrderBy(orderBy) {
+    return compileCanonicalOrderBy(orderBy, { contractId: "contract_row.contract_id", createdEventOffset: "created_tx.offset", createdAt: "created_tx.effective_at", archivedEventOffset: "archived_tx.offset", archivedAt: "archived_tx.effective_at" });
+}
+function compileCanonicalPhysicalOrderBy(relation, orderBy, alias, profile) {
+    if (relation === "__contracts") {
+        return compileCanonicalOrderBy(orderBy, {
+            contractId: qualified(alias, "contract_id"),
+            createdEventOffset: contractTransactionFieldExpression(alias, "created", "offset", profile),
+            createdAt: contractTransactionFieldExpression(alias, "created", "effective_at", profile),
+            archivedEventOffset: contractTransactionFieldExpression(alias, "archived", "offset", profile),
+            archivedAt: contractTransactionFieldExpression(alias, "archived", "effective_at", profile),
+        });
+    }
+    return compileCanonicalOrderBy(orderBy, Object.fromEntries(Object.keys(pqsRelationMetadata[relation].fields).map((field) => [field, compileCanonicalPhysicalField(relation, field, alias, profile)])));
 }
-export function compileContractGroupBy(args, profile) {
-    if (args.by.length === 0 || (!args.aggregate.count && !args.aggregate.min && !args.aggregate.max && !args.aggregate.sum))
+function compileCanonicalOrderBy(orderBy, fields) {
+    return orderBy.length === 0 ? "" : ` order by ${orderBy.map((order) => `${fields[order.path[0]]} ${order.direction}`).join(", ")}`;
+}
+function pqsRelation(relation) {
+    return { contracts: "__contracts", contractTypes: "__contract_tpe", events: "__events", exercises: "__exercises", exerciseTypes: "__exercise_tpe", packages: "__packages", transactions: "__transactions", watermark: "__watermark" }[relation];
+}
+export function compileContractGroupBy(query, profile) {
+    if (query.relation !== "contracts")
+        throw new Error("compileContractGroupBy requires a contracts query");
+    if (query.by.length === 0 || (!query.aggregates.count && query.aggregates.min.length === 0 && query.aggregates.max.length === 0 && query.aggregates.sum.length === 0))
         throw new Error("groupBy requires keys and an aggregate");
     const values = [];
     const add = (value) => { values.push(value); return `$${values.length}`; };
-    const where = args.where === undefined ? undefined : compileWhere(args.where, add, profile);
+    const where = query.predicate === undefined ? undefined : compileCanonicalContractPredicate(query.predicate, add, profile, "contract_row");
     const fields = {
         contractId: "contract_row.contract_id",
-        createdEventOffset: "contract_row.created_at_ix",
-        archivedEventOffset: "contract_row.archived_at_ix",
+        createdEventOffset: "created_tx.offset",
+        createdAt: "created_tx.effective_at",
+        archivedEventOffset: "archived_tx.offset",
+        archivedAt: "archived_tx.effective_at",
     };
     const expressions = [];
     const select = [];
     let unnestWitnesses = false;
-    for (const key of args.by) {
-        if (key === "witnesses") {
+    for (const key of query.by) {
+        if (key.kind === "field" && key.path[0] === "witnesses") {
             unnestWitnesses = true;
             expressions.push("witness.value");
             select.push("witness.value as \"witnesses\"");
         }
-        else if (typeof key === "string") {
-            const expression = fields[key];
+        else if (key.kind === "field") {
+            const expression = fields[key.path[0]];
             if (expression === undefined)
-                throw new Error(`${key} is not a contract group key`);
+                throw new Error(`${key.path[0]} is not a contract group key`);
             expressions.push(expression);
-            select.push(`${expression} as "${key}"`);
+            select.push(`${expression} as "${key.path[0]}"`);
         }
         else {
-            const payload = key.payload;
-            if (payload.path.length === 0 || payload.path.some((segment) => segment.length === 0))
-                throw new Error("payload group path must be non-empty");
-            const base = `contract_row.payload #>> ${add(payload.path)}::text[]`;
-            const cast = payload.as === "text" ? base : `(${base})::${payload.as === "numeric" ? "numeric" : payload.as === "boolean" ? "boolean" : "timestamptz"}`;
+            if (key.kind !== "json" || key.field !== "payload")
+                throw new Error("invalid contract group key");
+            const base = `contract_row.payload #>> ${add(key.path)}::text[]`;
+            const cast = key.as === "text" ? base : `(${base})::${key.as === "numeric" ? "numeric" : key.as === "boolean" ? "boolean" : "timestamptz"}`;
             expressions.push(cast);
-            select.push(`${cast} as "${payload.name}"`);
+            select.push(`${cast} as ${quotePqsIdentifier(key.name)}`);
         }
     }
-    if (args.aggregate.count)
+    if (query.aggregates.count)
         select.push("count(*)::text as count");
-    for (const [operation, requested] of [["min", args.aggregate.min], ["max", args.aggregate.max], ["sum", args.aggregate.sum]]) {
-        for (const name of requested ?? []) {
+    for (const [operation, requested] of [["min", query.aggregates.min], ["max", query.aggregates.max], ["sum", query.aggregates.sum]]) {
+        for (const name of requested) {
             const expression = fields[name];
             select.push(`${operation}(${expression})::text as "${operation}_${name}"`);
         }
     }
     return {
-        text: `select ${select.join(", ")} from ${profile.relation("__contracts")} contract_row${unnestWitnesses ? " cross join lateral unnest(contract_row.witnesses) as witness(value)" : ""}${where === undefined ? "" : ` where ${where}`} group by ${expressions.join(", ")}`,
+        text: `select ${select.join(", ")} ${contractFrom(profile)}${unnestWitnesses ? " cross join lateral unnest(contract_row.witnesses) as witness(value)" : ""}${where === undefined ? "" : ` where ${where}`} group by ${expressions.join(", ")}`,
         values,
     };
 }
-function compileWhere(where, addValue, profile) {
-    const columns = { contractId: "contract_row.contract_id", packageId: "contract_row.creation_package_id", createdEventOffset: "contract_row.created_at_ix", createdAt: "created_tx.effective_at", archivedEventOffset: "contract_row.archived_at_ix", archivedAt: "archived_tx.effective_at" };
-    const parts = [];
-    for (const [key, value] of Object.entries(where)) {
-        if (key === "and" || key === "or") {
-            if (!Array.isArray(value))
-                throw new Error(`${key} must be an array`);
-            parts.push(value.length === 0 ? key === "and" ? "true" : "false" : `(${value.map((child) => compileWhere(child, addValue, profile)).join(` ${key} `)})`);
-            continue;
-        }
-        if (key === "not") {
-            parts.push(`not (${compileWhere(value, addValue, profile)})`);
-            continue;
-        }
-        if (key === "active") {
-            const active = typeof value === "boolean" ? value : value.equals;
-            if (typeof active !== "boolean")
-                throw new Error("active supports only equals");
-            parts.push(active ? "contract_row.archived_at_ix is null" : "contract_row.archived_at_ix is not null");
-            continue;
-        }
-        if (key === "witnesses") {
-            const has = value.has;
-            if (has === undefined)
-                throw new Error("witnesses supports only has");
-            parts.push(`${addValue(has)} = any(contract_row.witnesses)`);
-            continue;
-        }
-        if (key === "payload") {
-            const payload = value;
-            const compilePayload = (path, filter) => { const ops = ["equals", "lt", "lte", "gt", "gte", "like", "ilike"].filter((op) => filter[op] !== undefined); if (ops.length === 1) {
-                const op = { equals: "=", lt: "<", lte: "<=", gt: ">", gte: ">=", like: "like", ilike: "ilike" }[ops[0]];
-                parts.push(`contract_row.payload #>> ${addValue(path)}::text[] ${op} ${addValue(filter[ops[0]])}`);
-                return;
-            } for (const [name, child] of Object.entries(filter))
-                compilePayload([...path, name], child); };
-            if (payload.match === undefined)
-                throw new Error("payload requires match");
-            compilePayload([], payload.match);
-            continue;
-        }
-        if (key === "templateId") {
-            const fields = { packageId: "contract_row.creation_package_id", moduleName: "contract_tpe_row.module_name", entityName: "contract_tpe_row.entity_name" };
-            for (const [name, filter] of Object.entries(value))
-                for (const [op, operand] of Object.entries(filter)) {
-                    const sql = { equals: "=", lt: "<", lte: "<=", gt: ">", gte: ">=", like: "like", ilike: "ilike" }[op];
-                    if (fields[name] === undefined || sql === undefined)
-                        throw new Error("invalid templateId filter");
-                    parts.push(`${fields[name]} ${sql} ${addValue(operand)}`);
-                }
-            continue;
-        }
-        const edge = pqsRelationEdges.__contracts?.[key];
-        if (edge !== undefined) {
-            parts.push(compilePhysicalRelationPredicate(edge.target, key, edge.targetColumn, edge.sourceColumn, edge.cardinality, value, "contract_row", profile, addValue));
-            continue;
-        }
-        const column = columns[key];
-        if (column === undefined || value === null || typeof value !== "object")
-            throw new Error(`${key} is not a supported contract filter`);
-        for (const [op, operand] of Object.entries(value)) {
-            const sql = { equals: "=", lt: "<", lte: "<=", gt: ">", gte: ">=", like: "like", ilike: "ilike" }[op];
-            if (sql !== undefined)
-                parts.push(`${column} ${sql} ${addValue(operand)}`);
-            else if (op === "is" && operand === null)
-                parts.push(`${column} is null`);
-            else if (op === "isNot" && operand === null)
-                parts.push(`${column} is not null`);
-            else if (op === "in" && Array.isArray(operand))
-                parts.push(operand.length ? `${column} = any(${addValue(operand)})` : "false");
-            else
-                throw new Error(`${op} is not supported for ${key}`);
-        }
-    }
-    return parts.length === 0 ? "true" : parts.join(" and ");
-}
-function compilePhysicalRelationPredicate(target, edgeName, targetColumn, sourceColumn, cardinality, value, parentAlias, profile, addValue) {
-    if (value === null || typeof value !== "object" || Array.isArray(value))
-        throw new Error(`${edgeName} must be a relation filter`);
-    const relation = value;
-    const alias = `"${edgeName}"`;
-    const join = `${alias}."${targetColumn}" = ${parentAlias}."${sourceColumn}"`;
-    if (cardinality === "one") {
-        const predicate = compilePhysicalWhere(target, relation, alias, profile, addValue);
-        return `exists (select 1 from ${profile.relation(target)} ${alias} where ${join} and (${predicate}))`;
-    }
-    const operators = ["some", "none", "every"].filter((name) => relation[name] !== undefined);
-    if (operators.length !== 1)
-        throw new Error(`${edgeName} requires exactly one of some, none, or every`);
-    const predicate = compilePhysicalWhere(target, relation[operators[0]], alias, profile, addValue);
-    const base = `select 1 from ${profile.relation(target)} ${alias} where ${join} and (${predicate})`;
-    return operators[0] === "some" ? `exists (${base})` : operators[0] === "none" ? `not exists (${base})` : `not exists (select 1 from ${profile.relation(target)} ${alias} where ${join} and not (${predicate}))`;
-}
-function compilePhysicalWhere(relation, expression, alias, profile, addValue) {
-    if (expression === null || typeof expression !== "object" || Array.isArray(expression))
-        throw new Error(`${relation} relation predicate must be an expression`);
-    const metadata = pqsRelationMetadata[relation];
-    const conditions = [];
-    for (const [field, value] of Object.entries(expression)) {
-        if (field === "and" || field === "or") {
-            if (!Array.isArray(value))
-                throw new Error(`${field} must be an array`);
-            conditions.push(value.length === 0 ? field === "and" ? "true" : "false" : `(${value.map((child) => compilePhysicalWhere(relation, child, alias, profile, addValue)).join(` ${field} `)})`);
-            continue;
-        }
-        if (field === "not") {
-            conditions.push(`not (${compilePhysicalWhere(relation, value, alias, profile, addValue)})`);
-            continue;
-        }
-        const edge = pqsRelationEdges[relation]?.[field];
-        if (edge !== undefined) {
-            conditions.push(compilePhysicalRelationPredicate(edge.target, field, edge.targetColumn, edge.sourceColumn, edge.cardinality, value, alias, profile, addValue));
-            continue;
-        }
-        const column = metadata.fields[field];
-        if (column === undefined || value === null || typeof value !== "object" || Array.isArray(value))
-            throw new Error(`${field} is not a field of ${relation}`);
-        const filter = value;
-        const text = PqsSchemaProfileV1.jsonField(relation, field) && Array.isArray(filter.path) ? `${alias}."${column}" #>> ${addValue(filter.path)}::text[]` : `${alias}."${column}"`;
-        if (Array.isArray(filter.path) && (filter.path.length === 0 || filter.path.some((segment) => typeof segment !== "string" || segment.length === 0)))
-            throw new Error(`${field}.path must be a non-empty JSON path`);
-        if (filter.is === null)
-            conditions.push(`${text} is null`);
-        if (filter.isNot === null)
-            conditions.push(`${text} is not null`);
-        if (filter.equals !== undefined)
-            conditions.push(`${text} = ${addValue(filter.equals)}`);
-        if (filter.in !== undefined) {
-            if (!Array.isArray(filter.in))
-                throw new Error(`${field}.in must be an array`);
-            conditions.push(filter.in.length === 0 ? "false" : `${text} = any(${addValue(filter.in)})`);
-        }
-        if (filter.has !== undefined) {
-            if (!metadata.arrayFields.includes(field))
-                throw new Error(`${field} is not an array field of ${relation}`);
-            conditions.push(`${addValue(filter.has)} = any(${alias}."${column}")`);
-        }
-        for (const [operator, operand] of Object.entries(filter)) {
-            const sql = { lt: "<", lte: "<=", gt: ">", gte: ">=", like: "like", ilike: "ilike" }[operator];
-            if (sql !== undefined)
-                conditions.push(`${text} ${sql} ${addValue(operand)}`);
-        }
-    }
-    return conditions.length === 0 ? "true" : conditions.join(" and ");
-}
-function compileOrderBy(orderBy) {
-    if (orderBy === undefined) {
-        return "order by contract_row.contract_id asc";
-    }
-    const fields = {
-        contractId: "contract_row.contract_id",
-        createdEventOffset: "contract_row.created_at_ix",
-        createdAt: "created_tx.effective_at",
-        archivedEventOffset: "contract_row.archived_at_ix",
-        archivedAt: "archived_tx.effective_at",
-    };
-    const entries = orderBy.flatMap((entry) => Object.entries(entry));
-    if (entries.some(([field, direction]) => fields[field] === undefined || (direction !== "asc" && direction !== "desc"))) {
-        throw new Error("orderBy must contain valid one-field entries");
-    }
-    return `order by ${entries.map(([field, direction]) => `${fields[field]} ${direction}`).join(", ")}`;
-}