@distrohelena/canton-typescript-sdk 0.1.36 → 0.1.37

package/dist/query/pqs/pqs-query-client.js

@@ -1,37 +1,33 @@
 import { QuerySource } from "../query-source.js";
 import { PqsQueryError } from "../errors/pqs-query-error.js";
-import { compileContractFindMany, compileContractGroupBy } from "./pqs-sql-compiler.js";
-import { compilePqsRelationGroupBy } from "./pqs-relational-sql-compiler.js";
-import { PqsSchemaProfileV1, pqsRelationEdges, pqsRelationMetadata, } from "./pqs-schema-profile.js";
+import { compileContractAggregate, compileContractCount, compileContractFindMany, compileContractGroupBy } from "./pqs-sql-compiler.js";
+import { compilePqsRelationAggregate, compilePqsRelationCount, compilePqsRelationFindMany, compilePqsRelationGroupBy, } from "./pqs-relational-sql-compiler.js";
+import { normalizeAggregate, normalizeCount, normalizeFindMany, normalizeFindUnique, normalizeGroupBy } from "../canonical/query-normalizer.js";
+import { pqsRelationMetadata } from "./pqs-schema-profile.js";
 import { assertReadOnlySql } from "./read-only-sql.js";
-const logicalContractFields = [
-    "contractId",
-    "templateId",
-    "packageId",
-    "payload",
-    "witnesses",
-    "createdEventOffset",
-    "createdAt",
-    "archivedEventOffset",
-    "archivedAt",
-    "active",
-];
+const queryRelationForPqs = {
+    __contracts: "contracts", __contract_tpe: "contractTypes", __events: "events", __exercises: "exercises",
+    __exercise_tpe: "exerciseTypes", __packages: "packages", __transactions: "transactions", __watermark: "watermark",
+};
+function normalizedUniqueAsFindMany(query) {
+    return {
+        kind: "findMany", relation: query.relation, predicate: query.predicate,
+        select: query.select, includes: query.includes,
+        orderBy: query.relation === "contracts" ? [{ path: ["contractId"], direction: "asc" }] : [],
+        skip: 0, take: 1, activeOnly: false,
+    };
+}
 export class PqsQueryClient {
     executor;
     profile;
     ready;
     source = QuerySource.pqs;
     contracts = {
-        findMany: (args = {}) => this.findContractsAsync(args),
-        findUnique: (args) => this.findContractsAsync({
-            where: { contractId: { equals: args.where.contractId } },
-            select: args.select,
-            include: args.include,
-            take: 1,
-        }).then((rows) => rows[0]),
-        count: async (args = {}) => (await this.findContractsAsync(args)).length,
-        aggregate: async (args) => this.aggregateContractsAsync(args),
-        groupBy: async (args) => this.groupContractsAsync(args),
+        findMany: async (args = {}) => await this.findContractsAsync(normalizeFindMany("contracts", args)),
+        findUnique: async (args) => (await this.findContractsAsync(normalizedUniqueAsFindMany(normalizeFindUnique("contracts", args))))[0],
+        count: async (args = {}) => this.countContractsAsync(normalizeCount("contracts", args)),
+        aggregate: async (args) => this.aggregateContractsAsync(normalizeAggregate("contracts", args)),
+        groupBy: async (args) => this.groupContractsAsync(normalizeGroupBy("contracts", args)),
     };
     contractTypes = this.createPhysicalDelegate("__contract_tpe");
     events = this.createPhysicalDelegate("__events");
@@ -55,105 +51,54 @@ export class PqsQueryClient {
             throw this.wrap("$queryRaw", cause);
         }
     }
+    async cacheContracts(_args) {
+        return { source: QuerySource.pqs, cached: false };
+    }
+    async invalidateContractsCache(_args) { }
     createPhysicalDelegate(relation, hasUnique = true) {
-        const metadata = pqsRelationMetadata[relation];
-        const findMany = async (args = {}) => this.readPhysicalAsync(relation, metadata, args);
+        const queryRelation = queryRelationForPqs[relation];
         const delegate = {
-            findMany,
-            count: async (args = {}) => {
-                const { where, values } = this.compileWhere(relation, metadata, args.where);
-                try {
-                    await this.ready;
-                    const result = await this.executor.query(`select count(*)::text as count from ${this.profile.relation(relation)}${where}`, values);
-                    return Number(result.rows[0]?.count ?? 0);
-                }
-                catch (cause) {
-                    throw this.wrap(`${relation}.count`, cause);
-                }
-            },
-            aggregate: async (args) => this.aggregatePhysicalAsync(relation, metadata, args),
-            groupBy: async (args) => this.groupPhysicalAsync(relation, args),
+            findMany: async (args = {}) => this.readPhysicalAsync(relation, normalizeFindMany(queryRelation, args)),
+            count: async (args = {}) => this.countPhysicalAsync(relation, normalizeCount(queryRelation, args)),
+            aggregate: async (args) => this.aggregatePhysicalAsync(relation, normalizeAggregate(queryRelation, args)),
+            groupBy: async (args) => this.groupPhysicalAsync(relation, normalizeGroupBy(queryRelation, args)),
         };
-        if (!hasUnique) {
-            return delegate;
-        }
-        return {
+        return hasUnique ? {
             ...delegate,
-            findUnique: async (args) => {
-                this.assertUniqueWhere(relation, metadata, args.where);
-                return findMany({
-                    where: Object.fromEntries(Object.entries(args.where).map(([field, value]) => [field, { equals: value }])),
-                    select: args.select,
-                    include: args.include,
-                    take: 1,
-                }).then((rows) => rows[0]);
-            },
-        };
+            findUnique: async (args) => (await this.readPhysicalAsync(relation, normalizedUniqueAsFindMany(normalizeFindUnique(queryRelation, args))))[0],
+        } : delegate;
     }
-    async groupPhysicalAsync(relation, args) {
-        const root = relation === "__events" ? '"event"' : '"root"';
-        const filter = this.compileWhere(relation, pqsRelationMetadata[relation], args.where, undefined, root);
-        const compiled = compilePqsRelationGroupBy(relation, args, this.profile, filter.values.length);
-        const text = filter.where.length === 0 ? compiled.text : compiled.text.replace(" group by ", `${filter.where} group by `);
+    async readPhysicalAsync(relation, query) {
+        const compiled = compilePqsRelationFindMany(relation, query, this.profile);
         try {
             await this.ready;
-            return (await this.executor.query(text, [...filter.values, ...compiled.values])).rows.map((row) => Object.fromEntries(Object.entries(row).map(([name, value]) => [name, name === "count" ? Number(value) : value instanceof Date ? value : value === null ? null : String(value)])));
+            return (await this.executor.query(compiled.text, compiled.values)).rows.map((row) => this.mapPhysicalRow(row, compiled.resultShape));
         }
         catch (cause) {
-            throw this.wrap(`${relation}.groupBy`, cause);
+            throw this.wrap(`${relation}.findMany`, cause);
         }
     }
-    async readPhysicalAsync(relation, metadata, args) {
-        this.assertPage(args);
-        const selected = this.selectedFields(relation, metadata, args.select);
-        const { where, values } = this.compileWhere(relation, metadata, args.where);
-        const orderBy = this.compileOrderBy(relation, metadata, args.orderBy);
-        const parameters = [...values];
-        const add = (value) => {
-            parameters.push(value);
-            return `$${parameters.length}`;
-        };
-        const limit = args.take === undefined ? "" : ` limit ${add(args.take)}`;
-        const offset = args.skip === undefined ? "" : ` offset ${add(args.skip)}`;
-        const selection = selected.map(([field, column]) => `"${column}" as "${field}"`).join(", ");
-        const includes = this.compileIncludes(relation, args.include, add);
-        const json = this.compileJsonSelections(relation, args.select?.json, add);
-        const fullSelection = [selection, ...json.selection, ...includes.selection].filter((value) => value.length > 0).join(", ");
+    async countPhysicalAsync(relation, query) {
+        const compiled = compilePqsRelationCount(relation, query, this.profile);
         try {
             await this.ready;
-            const result = await this.executor.query(`select ${fullSelection} from ${this.profile.relation(relation)}${where}${orderBy}${limit}${offset}`, parameters);
-            return result.rows.map((row) => this.mapPhysicalRow(row, metadata, selected, includes.values, json.fields));
+            return Number((await this.executor.query(compiled.text, compiled.values)).rows[0]?.count ?? 0);
         }
         catch (cause) {
-            throw this.wrap(`${relation}.findMany`, cause);
+            throw this.wrap(`${relation}.count`, cause);
         }
     }
-    async aggregatePhysicalAsync(relation, metadata, args) {
-        const { where, values } = this.compileWhere(relation, metadata, args.where);
-        const selected = [];
-        if (args.count) {
-            selected.push("count(*)::text as count");
-        }
-        for (const [operation, fields] of [["min", args.min], ["max", args.max], ["sum", args.sum]]) {
-            for (const field of fields ?? []) {
-                this.assertNumericField(relation, metadata, field);
-                selected.push(`${operation}("${metadata.fields[field]}")::text as "${operation}_${field}"`);
-            }
-        }
-        if (selected.length === 0) {
-            throw new Error("aggregate must request at least one result");
-        }
+    async aggregatePhysicalAsync(relation, query) {
+        const compiled = compilePqsRelationAggregate(relation, query, this.profile);
         try {
             await this.ready;
-            const row = (await this.executor.query(`select ${selected.join(", ")} from ${this.profile.relation(relation)}${where}`, values)).rows[0] ?? {};
+            const row = (await this.executor.query(compiled.text, compiled.values)).rows[0] ?? {};
             const result = {};
-            if (args.count) {
+            if (query.aggregates.count)
                 result.count = Number(row.count ?? 0);
-            }
-            for (const [operation, fields] of [["min", args.min], ["max", args.max], ["sum", args.sum]]) {
-                if (fields !== undefined) {
+            for (const [operation, fields] of [["min", query.aggregates.min], ["max", query.aggregates.max], ["sum", query.aggregates.sum]]) {
+                if (fields.length > 0)
                     result[operation] = Object.fromEntries(fields.map((field) => [field, nullableString(row[`${operation}_${field}`])]));
-                }
             }
             return result;
         }
@@ -161,403 +106,79 @@ export class PqsQueryClient {
             throw this.wrap(`${relation}.aggregate`, cause);
         }
     }
-    compileWhere(relation, metadata, filters, externalAdd, parentExpression = this.profile.relation(relation)) {
-        const values = [];
-        const add = externalAdd ?? ((value) => {
-            values.push(value);
-            return `$${values.length}`;
-        });
-        if (relation === "__contracts") {
-            const where = this.compileLogicalContractWhere(filters, add, parentExpression);
-            return { where: where === "true" ? "" : ` where ${where}`, values };
-        }
-        const compile = (expression) => {
-            const conditions = [];
-            for (const [field, filter] of Object.entries(expression ?? {})) {
-                if (field === "and" || field === "or") {
-                    if (!Array.isArray(filter))
-                        throw new Error(`${field} must be an array`);
-                    conditions.push(filter.length ? `(${filter.map((child) => compile(child)).join(` ${field} `)})` : field === "and" ? "true" : "false");
-                    continue;
-                }
-                if (field === "not") {
-                    if (filter === null || Array.isArray(filter) || typeof filter !== "object")
-                        throw new Error("not must be an expression");
-                    conditions.push(`not (${compile(filter)})`);
-                    continue;
-                }
-                const edge = pqsRelationEdges[relation]?.[field];
-                if (edge !== undefined) {
-                    if (filter === null || Array.isArray(filter) || typeof filter !== "object")
-                        throw new Error(`${field} must be a relation filter`);
-                    const related = filter;
-                    const alias = `"${field}"`;
-                    const relatedCondition = (child) => {
-                        const where = this.compileWhere(edge.target, pqsRelationMetadata[edge.target], child, add, alias).where;
-                        return where.length === 0 ? "true" : where.slice(" where ".length);
-                    };
-                    const join = `${alias}."${edge.targetColumn}" = ${parentExpression}."${edge.sourceColumn}"`;
-                    if (edge.cardinality === "one") {
-                        if (Object.keys(related).some((name) => ["some", "none", "every"].includes(name)))
-                            throw new Error(`${field} is a to-one relation`);
-                        conditions.push(`exists (select 1 from ${this.profile.relation(edge.target)} ${alias} where ${join} and (${relatedCondition(related)}))`);
-                    }
-                    else {
-                        const operators = ["some", "none", "every"].filter((name) => related[name] !== undefined);
-                        if (operators.length !== 1)
-                            throw new Error(`${field} requires exactly one of some, none, or every`);
-                        const operator = operators[0];
-                        const predicate = related[operator];
-                        const condition = relatedCondition(predicate);
-                        const subquery = `select 1 from ${this.profile.relation(edge.target)} ${alias} where ${join} and (${condition})`;
-                        if (operator === "some")
-                            conditions.push(`exists (${subquery})`);
-                        else if (operator === "none")
-                            conditions.push(`not exists (${subquery})`);
-                        else
-                            conditions.push(`not exists (select 1 from ${this.profile.relation(edge.target)} ${alias} where ${join} and not (${condition}))`);
-                    }
-                    continue;
-                }
-                const column = this.field(relation, metadata, field);
-                if (filter === null || Array.isArray(filter) || typeof filter !== "object")
-                    throw new Error(`${field} must be a filter`);
-                const scalar = filter;
-                if (PqsSchemaProfileV1.jsonField(relation, field) && scalar.path !== undefined) {
-                    if (scalar.path.length === 0 || scalar.path.some((segment) => segment.length === 0))
-                        throw new Error(`${field}.path must be a non-empty JSON path`);
-                    const expression = `"${column}" #>> ${add(scalar.path)}::text[]`;
-                    if (scalar.is === null)
-                        conditions.push(`${expression} is null`);
-                    if (scalar.isNot === null)
-                        conditions.push(`${expression} is not null`);
-                    if (scalar.equals !== undefined)
-                        conditions.push(`${expression} = ${add(scalar.equals)}`);
-                    if (scalar.in !== undefined)
-                        conditions.push(scalar.in.length === 0 ? "false" : `${expression} = any(${add(scalar.in)})`);
-                    for (const [operator, value] of [["lt", scalar.lt], ["lte", scalar.lte], ["gt", scalar.gt], ["gte", scalar.gte], ["like", scalar.like], ["ilike", scalar.ilike]]) {
-                        if (value !== undefined)
-                            conditions.push(`${expression} ${operator === "lte" ? "<=" : operator === "gte" ? ">=" : operator} ${add(value)}`);
-                    }
-                    continue;
-                }
-                if (scalar.is === null) {
-                    conditions.push(`"${column}" is null`);
-                }
-                if (scalar.isNot === null) {
-                    conditions.push(`"${column}" is not null`);
-                }
-                if (scalar.equals !== undefined) {
-                    conditions.push(`"${column}" = ${add(scalar.equals)}`);
-                }
-                if (scalar.in !== undefined) {
-                    conditions.push(scalar.in.length === 0 ? "false" : `"${column}" = any(${add(scalar.in)})`);
-                }
-                if (scalar.has !== undefined) {
-                    if (!metadata.arrayFields.includes(field)) {
-                        throw new Error(`${field} is not an array field of ${relation}`);
-                    }
-                    conditions.push(`${add(scalar.has)} = any("${column}")`);
-                }
-                for (const [operator, value] of [["lt", scalar.lt], ["lte", scalar.lte], ["gt", scalar.gt], ["gte", scalar.gte], ["like", scalar.like], ["ilike", scalar.ilike]]) {
-                    if (value === undefined)
-                        continue;
-                    if ((operator === "like" || operator === "ilike") && !metadata.stringFields?.includes(field))
-                        throw new Error(`${field} does not support ${operator}`);
-                    if ((operator !== "like" && operator !== "ilike") && !metadata.numericFields.includes(field) && !metadata.dateFields.includes(field) && !metadata.stringFields?.includes(field))
-                        throw new Error(`${field} does not support ${operator}`);
-                    conditions.push(`"${column}" ${operator === "lte" ? "<=" : operator === "gte" ? ">=" : operator} ${add(value)}`);
-                }
-            }
-            return conditions.length ? conditions.join(" and ") : "true";
-        };
-        const where = compile(filters);
-        return { where: where === "true" ? "" : ` where ${where}`, values };
-    }
-    compileLogicalContractWhere(filters, add, alias) {
-        const compile = (expression) => {
-            const conditions = [];
-            for (const [field, filter] of Object.entries(expression ?? {})) {
-                if (field === "and" || field === "or") {
-                    if (!Array.isArray(filter))
-                        throw new Error(`${field} must be an array`);
-                    conditions.push(filter.length === 0 ? field === "and" ? "true" : "false" : `(${filter.map((child) => compile(child)).join(` ${field} `)})`);
-                    continue;
-                }
-                if (field === "not") {
-                    conditions.push(`not (${compile(filter)})`);
-                    continue;
-                }
-                if (field === "active") {
-                    const value = typeof filter === "boolean" ? filter : filter.equals;
-                    if (typeof value !== "boolean")
-                        throw new Error("active supports only equals");
-                    conditions.push(`${alias}."archived_at_ix" is ${value ? "null" : "not null"}`);
-                    continue;
-                }
-                if (field === "witnesses") {
-                    const value = filter.has;
-                    if (typeof value !== "string")
-                        throw new Error("witnesses supports only has");
-                    conditions.push(`${add(value)} = any(${alias}."witnesses")`);
-                    continue;
-                }
-                if (field === "payload") {
-                    const match = filter.match;
-                    if (match === undefined || typeof match !== "object" || match === null)
-                        throw new Error("payload requires match");
-                    for (const [key, value] of Object.entries(match))
-                        if (value.equals !== undefined)
-                            conditions.push(`${alias}."payload" #>> ${add([key])}::text[] = ${add(value.equals)}`);
-                    continue;
-                }
-                const columns = { contractId: "contract_id", packageId: "creation_package_id", createdEventOffset: "created_at_ix", archivedEventOffset: "archived_at_ix" };
-                const column = columns[field];
-                if (column === undefined || filter === null || typeof filter !== "object")
-                    throw new Error(`${field} is not a supported contract filter`);
-                const value = filter;
-                if (value.equals !== undefined)
-                    conditions.push(`${alias}."${column}" = ${add(value.equals)}`);
-                else if (value.in !== undefined)
-                    conditions.push(value.in.length === 0 ? "false" : `${alias}."${column}" = any(${add(value.in)})`);
-                else
-                    throw new Error(`${field} requires equals or in`);
-            }
-            return conditions.length === 0 ? "true" : conditions.join(" and ");
-        };
-        return compile(filters);
-    }
-    selectedFields(relation, metadata, select) {
-        if (select === undefined) {
-            return Object.entries(metadata.fields);
-        }
-        const selected = Object.entries(select).filter(([field, enabled]) => field !== "json" && enabled === true).map(([field]) => [field, this.field(relation, metadata, field)]);
-        if (selected.length === 0 && Object.keys(select.json ?? {}).length === 0) {
-            throw new Error("select must include at least one field");
-        }
-        return selected;
-    }
-    compileOrderBy(relation, metadata, orderBy) {
-        if (orderBy === undefined) {
-            return "";
-        }
-        const entries = orderBy.flatMap((entry) => Object.entries(entry));
-        if (entries.length === 0 || entries.some(([, direction]) => direction !== "asc" && direction !== "desc")) {
-            throw new Error("orderBy must be a non-empty list of one-field entries");
-        }
-        return ` order by ${entries.map(([field, direction]) => `"${this.field(relation, metadata, field)}" ${direction}`).join(", ")}`;
-    }
-    assertUniqueWhere(relation, metadata, where) {
-        const fields = Object.keys(where).sort();
-        const matches = metadata.uniqueKeys.some((key) => [...key].sort().join("\0") === fields.join("\0"));
-        if (!matches) {
-            throw new Error(`where is not a stable unique key of ${relation}`);
-        }
-    }
-    assertNumericField(relation, metadata, field) {
-        if (!metadata.numericFields.includes(field)) {
-            throw new Error(`${field} is not a numeric aggregate field of ${relation}`);
+    async groupPhysicalAsync(relation, query) {
+        const compiled = compilePqsRelationGroupBy(relation, query, this.profile);
+        try {
+            await this.ready;
+            return (await this.executor.query(compiled.text, compiled.values)).rows.map((row) => Object.fromEntries(Object.entries(row).map(([name, value]) => [name, name === "count" ? Number(value) : value instanceof Date ? value : value === null ? null : String(value)])));
         }
-    }
-    field(relation, metadata, field) {
-        const column = metadata.fields[field];
-        if (column === undefined) {
-            throw new Error(`${field} is not a field of ${relation}`);
+        catch (cause) {
+            throw this.wrap(`${relation}.groupBy`, cause);
         }
-        return column;
     }
-    assertPage(args) {
-        for (const [name, value] of [["take", args.take], ["skip", args.skip]]) {
-            if (value !== undefined && (!Number.isInteger(value) || value < 0)) {
-                throw new Error(`${name} must be a non-negative integer`);
-            }
+    mapPhysicalRow(row, shape, scalarSource = row) {
+        const metadata = pqsRelationMetadata[shape.relation];
+        const scalar = Object.fromEntries(shape.fields
+            .filter(({ name }) => Object.hasOwn(scalarSource, name) || Object.hasOwn(scalarSource, metadata.fields[name] ?? ""))
+            .map(({ name }) => [name, mapPhysicalValue(scalarSource[name] ?? scalarSource[metadata.fields[name] ?? ""], shape.relation, metadata, name)]));
+        const projected = Object.fromEntries(shape.json.map((projection) => [projection.name, mapJsonValue(row[projection.name], projection.as)]));
+        const included = Object.fromEntries(shape.includes.map((include) => [include.edge, this.mapIncludedPhysicalValue(row[include.edge], include)]));
+        return { ...scalar, ...projected, ...included };
+    }
+    mapIncludedPhysicalValue(value, include) {
+        if (include.cardinality === "many") {
+            if (value === null || value === undefined)
+                return [];
+            if (!Array.isArray(value))
+                throw new Error(`Invalid included ${include.target} rows`);
+            return value.map((entry) => this.mapIncludedPhysicalValue(entry, { ...include, cardinality: "one" }));
         }
-    }
-    mapPhysicalRow(row, metadata, fields, includes, json = {}) {
-        const scalar = Object.fromEntries(fields
-            .filter(([field]) => Object.hasOwn(row, field))
-            .map(([field]) => [field, mapPhysicalValue(row[field], metadata, field)]));
-        const related = Object.fromEntries(Object.entries(includes).map(([name, edge]) => [name, this.mapRelatedValue(row[name], edge.target, edge.options)]));
-        const projected = Object.fromEntries(Object.entries(json).map(([name, as]) => [name, mapJsonValue(row[name], as)]));
-        return { ...scalar, ...projected, ...related };
-    }
-    mapRelatedValue(value, relation, options) {
         if (value === null || value === undefined)
-            return value ?? null;
-        if (Array.isArray(value))
-            return value.map((entry) => this.mapRelatedValue(entry, relation, options));
-        if (typeof value !== "object")
-            throw new Error(`Invalid included ${relation} row`);
-        if (relation === "__contracts")
-            return this.mapLogicalContractValue(value, options);
-        const metadata = pqsRelationMetadata[relation];
-        const row = value;
-        const fields = this.selectedFields(relation, metadata, options.select);
-        const nested = Object.fromEntries(Object.entries(options.include ?? {}).map(([name, option]) => {
-            const edge = pqsRelationEdges[relation]?.[name];
-            if (edge === undefined)
-                throw new Error(`${name} is not a relation of ${relation}`);
-            return [name, { target: edge.target, options: option === true ? {} : option }];
-        }));
-        const json = Object.fromEntries(Object.entries(options.select?.json ?? {}).map(([name, projection]) => [name, projection.as]));
-        const normalized = Object.fromEntries(fields
-            .filter(([field, column]) => Object.hasOwn(row, field) || Object.hasOwn(row, column))
-            .map(([field, column]) => [field, row[field] ?? row[column]]));
-        for (const name of Object.keys(nested))
-            normalized[name] = row[name];
-        for (const name of Object.keys(json))
-            normalized[name] = row[name];
-        return this.mapPhysicalRow(normalized, metadata, fields, nested, json);
-    }
-    mapLogicalContractValue(row, options) {
-        const fields = options.select === undefined
-            ? logicalContractFields
-            : Object.entries(options.select).filter(([field, enabled]) => field !== "json" && enabled === true).map(([field]) => {
-                if (!logicalContractFields.includes(field))
-                    throw new Error(`${field} is not a field of __contracts`);
-                return field;
-            });
-        const scalar = Object.fromEntries(fields.filter((field) => Object.hasOwn(row, field)).map((field) => [field, row[field]]));
-        const relations = Object.fromEntries(Object.entries(options.include ?? {}).map(([name, option]) => {
-            const edge = pqsRelationEdges.__contracts?.[name];
-            if (edge === undefined)
-                throw new Error(`${name} is not a relation of __contracts`);
-            return [name, this.mapRelatedValue(row[name], edge.target, option === true ? {} : option)];
-        }));
-        const json = Object.fromEntries(Object.entries(options.select?.json ?? {}).map(([name, projection]) => [name, mapJsonValue(row[name], projection.as)]));
-        return { ...scalar, ...json, ...relations };
-    }
-    compileIncludes(relation, include, add, parentExpression = this.profile.relation(relation)) {
-        const selections = [];
-        const values = {};
-        for (const [name, option] of Object.entries(include ?? {})) {
-            const edge = pqsRelationEdges[relation]?.[name];
-            if (edge === undefined)
-                throw new Error(`${name} is not a relation of ${relation}`);
-            const options = option === true ? {} : option;
-            if (edge.cardinality === "many" && options.take === undefined)
-                throw new Error(`${name} is a to-many relation and requires take`);
-            if (options.take !== undefined && (!Number.isInteger(options.take) || options.take < 0))
-                throw new Error(`${name}.take must be a non-negative integer`);
-            const expression = this.compileIncludedExpression(name, edge.target, edge.sourceColumn, edge.targetColumn, edge.cardinality, options, add, parentExpression);
-            selections.push(`${expression} as "${name}"`);
-            values[name] = { target: edge.target, options };
-        }
-        return { selection: selections, values };
-    }
-    compileJsonSelections(relation, selections, add, tableAlias) {
-        const selection = [];
-        const fields = {};
-        for (const [name, projection] of Object.entries(selections ?? {})) {
-            if (!PqsSchemaProfileV1.jsonField(relation, projection.field))
-                throw new Error(`${projection.field} is not a JSON field of ${relation}`);
-            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 column = this.field(relation, pqsRelationMetadata[relation], projection.field);
-            const text = `${tableAlias === undefined ? "" : `${tableAlias}.`}"${column}" #>> ${add(projection.path)}::text[]`;
-            const expression = projection.as === "text" ? text : projection.as === "numeric" ? `(${text})::numeric::text` : projection.as === "boolean" ? `(${text})::boolean` : `(${text})::timestamptz`;
-            selection.push(`${expression} as "${name}"`);
-            fields[name] = projection.as;
-        }
-        return { selection, fields };
-    }
-    compileIncludedExpression(name, target, sourceColumn, targetColumn, cardinality, options, add, parentExpression) {
-        const alias = `"${name}"`;
-        const targetMetadata = pqsRelationMetadata[target];
-        const fields = target === "__contracts" ? [] : this.selectedFields(target, targetMetadata, options.select);
-        const json = target === "__contracts"
-            ? this.compileLogicalContractJsonSelections(options.select?.json, add, alias)
-            : this.compileJsonSelections(target, options.select?.json, add, alias).selection;
-        const nested = this.compileIncludes(target, options.include, add, alias).selection;
-        const scalarSelections = target === "__contracts"
-            ? this.compileLogicalContractSelections(alias, options.select)
-            : fields.map(([field, column]) => `'${field}', ${alias}."${column}"`);
-        const object = `jsonb_build_object(${[...scalarSelections, ...[...json, ...nested].flatMap((selection) => {
-                const match = /^(.*) as "([^"]+)"$/.exec(selection);
-                return match === null ? [] : [`'${match[2]}', ${match[1]}`];
-            })].join(", ")})`;
-        const { where } = this.compileWhere(target, targetMetadata, options.where, add, alias);
-        const condition = `${alias}."${targetColumn}" = ${parentExpression}."${sourceColumn}"`;
-        const childWhere = where.length === 0 ? ` where ${condition}` : `${where} and ${condition}`;
-        if (cardinality === "one")
-            return `(select ${object} from ${this.profile.relation(target)} ${alias}${childWhere})`;
-        const orderBy = this.compileOrderBy(target, targetMetadata, options.orderBy);
-        return `(select coalesce(jsonb_agg("${name}_limited".value), '[]'::jsonb) from (select ${object} as value from ${this.profile.relation(target)} ${alias}${childWhere}${orderBy} limit ${add(options.take)}) "${name}_limited")`;
-    }
-    compileLogicalContractSelections(alias, select) {
-        const selected = select === undefined
-            ? logicalContractFields
-            : Object.entries(select).filter(([field, enabled]) => field !== "json" && enabled === true).map(([field]) => field);
-        if (selected.length === 0 && Object.keys(select?.json ?? {}).length === 0)
-            throw new Error("select must include at least one field");
-        const expressions = {
-            contractId: `${alias}."contract_id"`,
-            templateId: `jsonb_build_object('packageId', ${alias}."creation_package_id", 'moduleName', (select contract_type."module_name" from ${this.profile.relation("__contract_tpe")} contract_type where contract_type."pk" = ${alias}."tpe_pk"), 'entityName', (select contract_type."entity_name" from ${this.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 ${this.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 ${this.profile.relation("__transactions")} archived_transaction where archived_transaction."ix" = ${alias}."archived_at_ix")`,
-            active: `${alias}."archived_at_ix" is null`,
-        };
-        return selected.map((field) => {
-            const expression = expressions[field];
-            if (expression === undefined)
-                throw new Error(`${field} is not a field of __contracts`);
-            return `'${field}', ${expression}`;
-        });
-    }
-    compileLogicalContractJsonSelections(selections, add, alias) {
-        return Object.entries(selections ?? {}).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 text = `${alias}."payload" #>> ${add(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 null;
+        if (typeof value !== "object" || Array.isArray(value))
+            throw new Error(`Invalid included ${include.target} row`);
+        return this.mapPhysicalRow(value, include.shape);
     }
-    async findContractsAsync(args) {
-        const compiled = compileContractFindMany(args, this.profile);
+    async findContractsAsync(query) {
+        const compiled = compileContractFindMany(query, this.profile);
         try {
-            const include = "include" in args ? args.include : undefined;
-            const rows = (await this.executor.query(compiled.text, compiled.values)).rows.map((row) => mapContractRow(row, include, "select" in args ? args.select?.json : undefined));
-            const select = "select" in args ? args.select : undefined;
-            if (select === undefined) {
-                return rows;
-            }
-            const fields = Object.entries(select).filter(([field, enabled]) => field !== "json" && enabled === true).map(([field]) => field);
-            const json = Object.keys(select.json ?? {});
-            if (fields.length === 0 && json.length === 0) {
-                throw new Error("select must include at least one field");
-            }
-            return rows.map((row) => Object.fromEntries([...fields.map((field) => [field, row[field]]), ...json.map((field) => [field, row[field]])]));
+            await this.ready;
+            return (await this.executor.query(compiled.text, compiled.values)).rows.map((row) => this.mapPhysicalRow(contractRootRow(row), compiled.resultShape, contractRootScalars(row)));
         }
         catch (cause) {
             throw this.wrap("contracts.findMany", cause);
         }
     }
-    async aggregateContractsAsync(args) {
-        if (!args.count && args.min === undefined && args.max === undefined && args.sum === undefined) {
-            throw new Error("aggregate must request at least one result");
+    async countContractsAsync(query) {
+        const compiled = compileContractCount(query, this.profile);
+        try {
+            await this.ready;
+            return Number((await this.executor.query(compiled.text, compiled.values)).rows[0]?.count ?? 0);
         }
-        const rows = await this.findContractsAsync({ where: args.where });
-        const result = {};
-        if (args.count) {
-            result.count = rows.length;
+        catch (cause) {
+            throw this.wrap("contracts.count", cause);
         }
-        for (const [operation, fields] of [["min", args.min], ["max", args.max], ["sum", args.sum]]) {
-            if (fields !== undefined) {
-                result[operation] = Object.fromEntries(fields.map((field) => [field, aggregateNumeric(rows.map((row) => row[field]), operation)]));
+    }
+    async aggregateContractsAsync(normalized) {
+        const compiled = compileContractAggregate(normalized, this.profile);
+        try {
+            await this.ready;
+            const row = (await this.executor.query(compiled.text, compiled.values)).rows[0] ?? {};
+            const result = {};
+            if (normalized.aggregates.count)
+                result.count = Number(row.count ?? 0);
+            for (const [operation, fields] of [["min", normalized.aggregates.min], ["max", normalized.aggregates.max], ["sum", normalized.aggregates.sum]]) {
+                if (fields.length > 0)
+                    result[operation] = Object.fromEntries(fields.map((field) => [field, nullableString(row[`${operation}_${field}`])]));
             }
+            return result;
+        }
+        catch (cause) {
+            throw this.wrap("contracts.aggregate", cause);
         }
-        return result;
     }
-    async groupContractsAsync(args) {
-        const compiled = compileContractGroupBy(args, this.profile);
+    async groupContractsAsync(query) {
+        const compiled = compileContractGroupBy(query, this.profile);
         try {
             await this.ready;
             return (await this.executor.query(compiled.text, compiled.values)).rows.map((row) => Object.fromEntries(Object.entries(row).map(([name, value]) => [name, name === "count" ? Number(value) : value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value instanceof Date ? value : String(value)])));
@@ -570,22 +191,39 @@ export class PqsQueryClient {
         return new PqsQueryError({ operation, code: getPqsCode(cause), cause });
     }
 }
-function mapPhysicalValue(value, metadata, field) {
-    if (value === null || value === undefined) {
+function mapPhysicalValue(value, relation, metadata, field) {
+    if (value === null || value === undefined)
         return value ?? null;
-    }
-    else if (metadata.numericFields.includes(field)) {
+    if (relation === "__events" && field === "eventId" && typeof value === "object" && !Array.isArray(value)) {
+        const event = value;
+        if (event.offset !== undefined && event.node_id !== undefined)
+            return `${String(event.offset)}:${String(event.node_id)}`;
+    }
+    if (relation === "__events" && field === "type") {
+        if (value === "create")
+            return "created";
+        if (value === "exercise")
+            return "exercised";
+    }
+    if (relation === "__transactions" && field === "workflowId" && value === "")
+        return null;
+    if (relation === "__transactions" && field === "traceContext" && typeof value === "object" && !Array.isArray(value)) {
+        const trace = value;
+        const traceparent = trace.traceparent ?? trace.trace_parent;
+        const tracestate = trace.tracestate ?? trace.trace_state;
+        return Object.fromEntries([
+            ...(traceparent === undefined || traceparent === null || traceparent === "" ? [] : [["traceparent", String(traceparent)]]),
+            ...(tracestate === undefined || tracestate === null || tracestate === "" ? [] : [["tracestate", String(tracestate)]]),
+        ]);
+    }
+    if (metadata.numericFields.includes(field))
         return String(value);
-    }
-    else if (metadata.dateFields.includes(field)) {
+    if (metadata.dateFields.includes(field))
         return value instanceof Date ? value : new Date(String(value));
-    }
-    else if (metadata.binaryFields.includes(field)) {
+    if (metadata.binaryFields.includes(field))
         return value instanceof Uint8Array ? value : new Uint8Array(value);
-    }
-    else if (metadata.arrayFields.includes(field)) {
+    if (metadata.arrayFields.includes(field))
         return Array.isArray(value) ? value.map(String) : [];
-    }
     return value;
 }
 function mapJsonValue(value, as) {
@@ -597,99 +235,30 @@ function mapJsonValue(value, as) {
         return value instanceof Date ? value : new Date(String(value));
     return String(value);
 }
-function mapProfileJsonRow(value, relation) {
-    if (value === null || value === undefined)
-        return null;
-    if (typeof value !== "object" || Array.isArray(value))
-        throw new Error(`Invalid included ${relation} row`);
-    const row = value;
-    const metadata = pqsRelationMetadata[relation];
-    return Object.fromEntries(Object.entries(metadata.fields).map(([field, column]) => [field, mapPhysicalValue(row[field] ?? row[column], metadata, field)]));
-}
-function mapSelectedProfileJsonRow(value, relation) {
-    if (value === null || value === undefined)
-        return null;
-    if (typeof value !== "object" || Array.isArray(value))
-        throw new Error(`Invalid included ${relation} row`);
-    const row = value;
-    const metadata = pqsRelationMetadata[relation];
-    return Object.fromEntries(Object.entries(metadata.fields)
-        .filter(([field, column]) => Object.hasOwn(row, field) || Object.hasOwn(row, column))
-        .map(([field, column]) => [field, mapPhysicalValue(row[field] ?? row[column], metadata, field)]));
-}
-function mapContractTypeJson(value) {
-    const row = mapProfileJsonRow(value, "__contract_tpe");
-    return row === null ? undefined : { pk: String(row.pk), payloadType: String(row.payloadType), aliases: stringArray(row.aliases), packageName: String(row.packageName), moduleName: String(row.moduleName), entityName: String(row.entityName), templateFqn: String(row.templateFqn) };
-}
-function mapTransactionJson(value) {
-    const row = mapProfileJsonRow(value, "__transactions");
-    return row === null ? undefined : { ix: String(row.ix), offset: String(row.offset), transactionId: nullableString(row.transactionId), effectiveAt: nullableDate(row.effectiveAt), workflowId: nullableString(row.workflowId), domainId: nullableString(row.domainId), traceContext: row.traceContext, externalTransactionHash: row.externalTransactionHash instanceof Uint8Array ? row.externalTransactionHash : null, paidTrafficCost: nullableString(row.paidTrafficCost) };
-}
-function mapEventJson(value) {
-    const row = mapSelectedProfileJsonRow(value, "__events");
-    return row ?? undefined;
-}
-function mapSelectedRelationJson(value, relation) {
-    const row = mapSelectedProfileJsonRow(value, relation);
-    return row ?? undefined;
-}
-function mapLogicalContractJson(value) {
-    if (value === null || value === undefined)
-        return undefined;
-    if (typeof value !== "object" || Array.isArray(value))
-        throw new Error("Invalid included __contracts row");
-    return value;
-}
-function mapExerciseJson(value) {
-    const raw = value;
-    const row = mapSelectedProfileJsonRow(value, "__exercises");
-    if (row === null)
-        throw new Error("Included exercise cannot be null");
-    const base = row;
-    const knownFields = new Set(Object.entries(pqsRelationMetadata.__exercises.fields).flatMap(([field, column]) => [field, column]));
-    const knownRelations = new Set(Object.keys(pqsRelationEdges.__exercises ?? {}));
-    const projections = Object.fromEntries(Object.entries(raw).filter(([name]) => !knownFields.has(name) && !knownRelations.has(name)));
-    return {
-        ...base,
-        ...projections,
-        ...(raw.exerciseType === undefined ? {} : { exerciseType: mapSelectedRelationJson(raw.exerciseType, "__exercise_tpe") }),
-        ...(raw.contractType === undefined ? {} : { contractType: mapSelectedRelationJson(raw.contractType, "__contract_tpe") }),
-        ...(raw.event === undefined ? {} : { event: raw.event === null ? null : mapEventJson(raw.event) ?? null }),
-        ...(raw.transaction === undefined ? {} : { transaction: raw.transaction === null ? null : mapTransactionJson(raw.transaction) ?? null }),
-        ...(raw.package === undefined ? {} : { package: mapSelectedRelationJson(raw.package, "__packages") }),
-        ...(raw.contract === undefined ? {} : { contract: mapLogicalContractJson(raw.contract) }),
+function contractRootScalars(row) {
+    const scalars = {
+        contractId: row.contract_id,
+        packageId: row.package_id,
+        payload: row.payload,
+        witnesses: row.witnesses,
+        createdEventOffset: row.created_event_offset,
+        createdAt: row.created_at,
+        archivedEventOffset: row.archived_event_offset,
+        archivedAt: row.archived_at,
+        active: row.active,
     };
+    if (row.template_package_id !== undefined && row.template_module_name !== undefined && row.template_entity_name !== undefined) {
+        scalars.templateId = { packageId: row.template_package_id, moduleName: row.template_module_name, entityName: row.template_entity_name };
+    }
+    return scalars;
 }
-function mapContractRow(row, include, json) {
-    const base = { contractId: String(row.contract_id), templateId: { packageId: String(row.template_package_id), moduleName: String(row.template_module_name), entityName: String(row.template_entity_name) }, packageId: nullableString(row.package_id), payload: row.payload, witnesses: stringArray(row.witnesses), createdEventOffset: String(row.created_event_offset), createdAt: nullableDate(row.created_at), archivedEventOffset: nullableString(row.archived_event_offset), archivedAt: nullableDate(row.archived_at), active: row.active === true };
-    const relations = {
-        ...(include?.contractType === undefined ? {} : { contractType: mapContractTypeJson(row.contractType ?? row.contract_type) }),
-        ...(include?.createdTransaction === undefined ? {} : { createdTransaction: mapTransactionJson(row.createdTransaction ?? row.created_transaction) }),
-        ...(include?.archivedTransaction === undefined ? {} : { archivedTransaction: (row.archivedTransaction ?? row.archived_transaction) === null || (row.archivedTransaction ?? row.archived_transaction) === undefined ? null : mapTransactionJson(row.archivedTransaction ?? row.archived_transaction) ?? null }),
-        ...(include?.exercises === undefined ? {} : { exercises: Array.isArray(row.exercises) ? row.exercises.map(mapExerciseJson) : [] }),
+function contractRootRow(row) {
+    return {
+        ...row,
+        contractType: row.contractType ?? row.contract_type,
+        createdTransaction: row.createdTransaction ?? row.created_transaction,
+        archivedTransaction: row.archivedTransaction ?? row.archived_transaction,
     };
-    const projections = Object.fromEntries(Object.entries(json ?? {}).map(([name, projection]) => [name, mapJsonValue(row[name], projection.as)]));
-    return { ...base, ...relations, ...projections };
-}
-function nullableString(value) {
-    return value === null || value === undefined ? null : String(value);
-}
-function nullableDate(value) {
-    return value === null || value === undefined ? null : value instanceof Date ? value : new Date(String(value));
-}
-function stringArray(value) {
-    return Array.isArray(value) ? value.map(String) : [];
-}
-function getPqsCode(cause) {
-    return typeof cause === "object" && cause !== null && "code" in cause && typeof cause.code === "string" ? cause.code : undefined;
-}
-function aggregateNumeric(values, operation) {
-    const numbers = values.filter((value) => value !== null).map(BigInt);
-    if (numbers.length === 0) {
-        return null;
-    }
-    else if (operation === "sum") {
-        return numbers.reduce((total, value) => total + value, 0n).toString();
-    }
-    return numbers.reduce((result, value) => operation === "min" ? value < result ? value : result : value > result ? value : result).toString();
 }
+function nullableString(value) { return value === null || value === undefined ? null : String(value); }
+function getPqsCode(cause) { return typeof cause === "object" && cause !== null && "code" in cause && typeof cause.code === "string" ? cause.code : undefined; }