@distrohelena/canton-typescript-sdk 0.1.16 → 0.1.18

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

@@ -1,8 +1,21 @@
 import { QuerySource } from "../query-source.js";
 import { PqsQueryError } from "../errors/pqs-query-error.js";
-import { compileContractFindMany } from "./pqs-sql-compiler.js";
-import { pqsRelationMetadata, } from "./pqs-schema-profile.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 { assertReadOnlySql } from "./read-only-sql.js";
+const logicalContractFields = [
+    "contractId",
+    "templateId",
+    "packageId",
+    "payload",
+    "witnesses",
+    "createdEventOffset",
+    "createdAt",
+    "archivedEventOffset",
+    "archivedAt",
+    "active",
+];
 export class PqsQueryClient {
     executor;
     profile;
@@ -13,10 +26,12 @@ export class PqsQueryClient {
         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),
     };
     contractTypes = this.createPhysicalDelegate("__contract_tpe");
     events = this.createPhysicalDelegate("__events");
@@ -57,6 +72,7 @@ export class PqsQueryClient {
                 }
             },
             aggregate: async (args) => this.aggregatePhysicalAsync(relation, metadata, args),
+            groupBy: async (args) => this.groupPhysicalAsync(relation, args),
         };
         if (!hasUnique) {
             return delegate;
@@ -68,11 +84,25 @@ export class PqsQueryClient {
                 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]);
             },
         };
     }
+    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 `);
+        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)])));
+        }
+        catch (cause) {
+            throw this.wrap(`${relation}.groupBy`, cause);
+        }
+    }
     async readPhysicalAsync(relation, metadata, args) {
         this.assertPage(args);
         const selected = this.selectedFields(relation, metadata, args.select);
@@ -86,10 +116,13 @@ export class PqsQueryClient {
         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(", ");
         try {
             await this.ready;
-            const result = await this.executor.query(`select ${selection} from ${this.profile.relation(relation)}${where}${orderBy}${limit}${offset}`, parameters);
-            return result.rows.map((row) => this.mapPhysicalRow(row, metadata, selected));
+            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));
         }
         catch (cause) {
             throw this.wrap(`${relation}.findMany`, cause);
@@ -128,12 +161,16 @@ export class PqsQueryClient {
             throw this.wrap(`${relation}.aggregate`, cause);
         }
     }
-    compileWhere(relation, metadata, filters) {
+    compileWhere(relation, metadata, filters, externalAdd, parentExpression = this.profile.relation(relation)) {
         const values = [];
-        const add = (value) => {
+        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 ?? {})) {
@@ -149,10 +186,61 @@ export class PqsQueryClient {
                     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`);
                 }
@@ -186,12 +274,65 @@ export class PqsQueryClient {
         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(([, enabled]) => enabled).map(([field]) => [field, this.field(relation, metadata, field)]);
-        if (selected.length === 0) {
+        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;
@@ -200,15 +341,11 @@ export class PqsQueryClient {
         if (orderBy === undefined) {
             return "";
         }
-        const entries = Object.entries(orderBy);
-        if (entries.length !== 1) {
-            throw new Error("orderBy must specify exactly one field");
+        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");
         }
-        const [field, direction] = entries[0];
-        if (direction !== "asc" && direction !== "desc") {
-            throw new Error("orderBy direction must be asc or desc");
-        }
-        return ` order by "${this.field(relation, metadata, field)}" ${direction}`;
+        return ` order by ${entries.map(([field, direction]) => `"${this.field(relation, metadata, field)}" ${direction}`).join(", ")}`;
     }
     assertUniqueWhere(relation, metadata, where) {
         const fields = Object.keys(where).sort();
@@ -236,24 +373,168 @@ export class PqsQueryClient {
             }
         }
     }
-    mapPhysicalRow(row, metadata, fields) {
-        return Object.fromEntries(fields
+    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}"`;
+        });
     }
     async findContractsAsync(args) {
         const compiled = compileContractFindMany(args, this.profile);
         try {
-            const rows = (await this.executor.query(compiled.text, compiled.values)).rows.map(mapContractRow);
+            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(([, enabled]) => enabled).map(([field]) => field);
-            if (fields.length === 0) {
+            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]])));
+            return rows.map((row) => Object.fromEntries([...fields.map((field) => [field, row[field]]), ...json.map((field) => [field, row[field]])]));
         }
         catch (cause) {
             throw this.wrap("contracts.findMany", cause);
@@ -275,6 +556,16 @@ export class PqsQueryClient {
         }
         return result;
     }
+    async groupContractsAsync(args) {
+        const compiled = compileContractGroupBy(args, 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)])));
+        }
+        catch (cause) {
+            throw this.wrap("contracts.groupBy", cause);
+        }
+    }
     wrap(operation, cause) {
         return new PqsQueryError({ operation, code: getPqsCode(cause), cause });
     }
@@ -297,8 +588,73 @@ function mapPhysicalValue(value, metadata, field) {
     }
     return value;
 }
-function mapContractRow(row) {
-    return { 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 };
+function mapJsonValue(value, as) {
+    if (value === null || value === undefined)
+        return null;
+    if (as === "boolean")
+        return value === true || value === "true";
+    if (as === "timestamp")
+        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 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.event === undefined ? {} : { event: raw.event === null ? null : mapEventJson(raw.event) ?? null }),
+        ...(raw.transaction === undefined ? {} : { transaction: raw.transaction === null ? null : mapTransactionJson(raw.transaction) ?? null }),
+    };
+}
+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) : [] }),
+    };
+    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);

package/dist/query/pqs/pqs-relational-sql-compiler.d.ts

@@ -0,0 +1,23 @@
+import { PqsRelation, PqsSchemaProfileV1 } from "./pqs-schema-profile.js";
+export interface CompiledPqsRelationQuery {
+    readonly text: string;
+    readonly values: readonly unknown[];
+}
+interface RelationFindManyArgs {
+    readonly where?: Readonly<Record<string, unknown>>;
+    readonly select?: Readonly<Record<string, boolean>>;
+    readonly orderBy?: readonly Readonly<Record<string, "asc" | "desc">>[];
+    readonly take?: number;
+    readonly skip?: number;
+}
+export declare function compilePqsRelationFindMany(relation: PqsRelation, args: RelationFindManyArgs, profile: PqsSchemaProfileV1): CompiledPqsRelationQuery;
+export declare function compilePqsRelationGroupBy(relation: PqsRelation, args: {
+    readonly by: readonly unknown[];
+    readonly aggregate: {
+        readonly count?: true;
+        readonly min?: readonly string[];
+        readonly max?: readonly string[];
+        readonly sum?: readonly string[];
+    };
+}, profile: PqsSchemaProfileV1, parameterOffset?: number): CompiledPqsRelationQuery;
+export {};