@distrohelena/canton-typescript-sdk 0.1.24 → 0.1.26

package/dist/daml-lf/model/lf-2-model-mapper.js

@@ -33,15 +33,23 @@ export class Lf2ModelMapper {
             const numericScale = lhs.builtinType === DamlLfBuiltinType.numeric
                 ? Lf2ModelMapper.readNumericScale(rawType.sum.tapp.rhs)
                 : undefined;
-            return numericScale === undefined
-                ? lhs
-                : new DamlLfType({
-                    builtinType: lhs.builtinType,
-                    numericScale,
-                    ...(lhs.typeConReference === undefined
+            return new DamlLfType({
+                builtinType: lhs.builtinType,
+                ...(numericScale === undefined
+                    ? lhs.numericScale === undefined
                         ? {}
-                        : { typeConReference: lhs.typeConReference }),
-                });
+                        : { numericScale: lhs.numericScale }
+                    : { numericScale }),
+                ...(lhs.typeConReference === undefined
+                    ? {}
+                    : { typeConReference: lhs.typeConReference }),
+                typeArguments: numericScale === undefined
+                    ? [
+                        ...lhs.typeArguments,
+                        Lf2ModelMapper.mapType(currentPackageId, rawPackage, rawType.sum.tapp.rhs),
+                    ]
+                    : lhs.typeArguments,
+            });
         }
         if (rawType?.sum.oneofKind === "forall") {
             return Lf2ModelMapper.mapType(currentPackageId, rawPackage, rawType.sum.forall.body);
@@ -49,31 +57,60 @@ export class Lf2ModelMapper {
         if (rawType?.sum.oneofKind === "con") {
             return new DamlLfType({
                 typeConReference: Lf2ModelMapper.mapTypeConReferenceOrThrow(currentPackageId, rawPackage, rawType.sum.con.tycon, rawType),
+                typeArguments: rawType.sum.con.args.map((item) => Lf2ModelMapper.mapType(currentPackageId, rawPackage, item)),
             });
         }
         else if (rawType?.sum.oneofKind === "builtin") {
-            const builtinType = rawType.sum.builtin.builtin === BuiltinType.INT64
-                ? DamlLfBuiltinType.int64
-                : rawType.sum.builtin.builtin === BuiltinType.NUMERIC
-                    ? DamlLfBuiltinType.numeric
-                    : rawType.sum.builtin.builtin === BuiltinType.PARTY
-                        ? DamlLfBuiltinType.party
-                        : rawType.sum.builtin.builtin === BuiltinType.TEXT
-                            ? DamlLfBuiltinType.text
-                            : DamlLfBuiltinType.unknown;
+            const builtinType = Lf2ModelMapper.mapBuiltinType(rawType.sum.builtin.builtin);
+            const numericScale = builtinType === DamlLfBuiltinType.numeric
+                ? Lf2ModelMapper.readNumericScale(rawType.sum.builtin.args[0])
+                : undefined;
             return new DamlLfType({
                 builtinType,
-                ...(builtinType !== DamlLfBuiltinType.numeric
+                ...(numericScale === undefined
                     ? {}
-                    : {
-                        numericScale: Lf2ModelMapper.readNumericScale(rawType.sum.builtin.args[0]),
-                    }),
+                    : { numericScale }),
+                typeArguments: rawType.sum.builtin.args
+                    .slice(numericScale === undefined ? 0 : 1)
+                    .map((item) => Lf2ModelMapper.mapType(currentPackageId, rawPackage, item)),
             });
         }
         return new DamlLfType({
             builtinType: DamlLfBuiltinType.unknown,
         });
     }
+    static mapBuiltinType(builtinType) {
+        switch (builtinType) {
+            case BuiltinType.UNIT:
+                return DamlLfBuiltinType.unit;
+            case BuiltinType.BOOL:
+                return DamlLfBuiltinType.bool;
+            case BuiltinType.INT64:
+                return DamlLfBuiltinType.int64;
+            case BuiltinType.DATE:
+                return DamlLfBuiltinType.date;
+            case BuiltinType.TIMESTAMP:
+                return DamlLfBuiltinType.timestamp;
+            case BuiltinType.NUMERIC:
+                return DamlLfBuiltinType.numeric;
+            case BuiltinType.PARTY:
+                return DamlLfBuiltinType.party;
+            case BuiltinType.TEXT:
+                return DamlLfBuiltinType.text;
+            case BuiltinType.CONTRACT_ID:
+                return DamlLfBuiltinType.contractId;
+            case BuiltinType.OPTIONAL:
+                return DamlLfBuiltinType.optional;
+            case BuiltinType.LIST:
+                return DamlLfBuiltinType.list;
+            case BuiltinType.TEXTMAP:
+                return DamlLfBuiltinType.textMap;
+            case BuiltinType.GENMAP:
+                return DamlLfBuiltinType.genMap;
+            default:
+                return DamlLfBuiltinType.unknown;
+        }
+    }
     static readNumericScale(rawType) {
         if (rawType?.sum.oneofKind !== "nat") {
             return undefined;
@@ -103,12 +140,31 @@ export class Lf2ModelMapper {
         });
     }
     static mapDataType(packageId, rawDataType, rawPackage) {
-        const fields = rawDataType.dataCons.oneofKind === "record"
-            ? rawDataType.dataCons.record.fields.map((item) => Lf2ModelMapper.mapField(packageId, item.fieldInternedStr, item.type, rawPackage))
-            : [];
+        const definition = rawDataType.dataCons.oneofKind === "record"
+            ? {
+                kind: "record",
+                fields: rawDataType.dataCons.record.fields.map((item) => Lf2ModelMapper.mapField(packageId, item.fieldInternedStr, item.type, rawPackage)),
+            }
+            : rawDataType.dataCons.oneofKind === "variant"
+                ? {
+                    kind: "variant",
+                    constructors: rawDataType.dataCons.variant.fields.map((item) => ({
+                        name: Lf2ModelMapper.resolveInternedString(rawPackage.internedStrings, item.fieldInternedStr),
+                        type: Lf2ModelMapper.mapType(packageId, rawPackage, item.type),
+                    })),
+                }
+                : rawDataType.dataCons.oneofKind === "enum"
+                    ? {
+                        kind: "enum",
+                        constructors: rawDataType.dataCons.enum.constructorsInternedStr.map((item) => Lf2ModelMapper.resolveInternedString(rawPackage.internedStrings, item)),
+                    }
+                    : undefined;
+        if (definition === undefined) {
+            return undefined;
+        }
         return new DamlLfDataType({
             name: Lf2ModelMapper.resolveInternedDottedName(rawPackage.internedStrings, rawPackage.internedDottedNames, rawDataType.nameInternedDname),
-            fields,
+            definition,
         });
     }
     static mapTemplateOrThrow(packageId, moduleName, rawTemplate, rawPackage, dataTypes) {

package/dist/daml-lf/semantics/daml-lf-semantic-model.d.ts

@@ -1,5 +1,6 @@
 import { DamlLfChoice } from "../model/daml-lf-choice.js";
 import { DamlLfCompilation } from "../daml-lf-compilation.js";
+import { DamlLfDataType } from "../model/daml-lf-data-type.js";
 import { DamlLfField } from "../model/daml-lf-field.js";
 import { DamlLfTemplate } from "../model/daml-lf-template.js";
 import { DamlLfTemplateId } from "../model/daml-lf-template-id.js";
@@ -13,4 +14,6 @@ export declare class DamlLfSemanticModel {
     getTemplateChoicesOrThrow(templateId: DamlLfTemplateId): readonly DamlLfChoice[];
     /** Returns the record fields for a resolved type constructor reference. */
     getRecordFieldsOrThrow(reference: TypeConReference): readonly DamlLfField[];
+    /** Returns the complete resolved data type for a type constructor reference. */
+    getDataTypeOrThrow(reference: TypeConReference): DamlLfDataType;
 }

package/dist/daml-lf/semantics/daml-lf-semantic-model.js

@@ -14,6 +14,10 @@ export class DamlLfSemanticModel {
     }
     /** Returns the record fields for a resolved type constructor reference. */
     getRecordFieldsOrThrow(reference) {
-        return this.compilation.getTypeSymbolOrThrow(reference).definition.fields;
+        return this.getDataTypeOrThrow(reference).fields;
+    }
+    /** Returns the complete resolved data type for a type constructor reference. */
+    getDataTypeOrThrow(reference) {
+        return this.compilation.getTypeSymbolOrThrow(reference).definition;
     }
 }

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

@@ -629,6 +629,17 @@ 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");
@@ -641,8 +652,12 @@ function mapExerciseJson(value) {
     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 mapContractRow(row, include, json) {

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

@@ -69,16 +69,16 @@ function compileProfileIncludes(source, parentAlias, include, profile, addValue)
         const alias = `"${name}"`;
         const nested = compileProfileIncludes(edge.target, alias, options.include, profile, addValue);
         const metadata = pqsRelationMetadata[edge.target];
-        const requested = options.select === undefined
-            ? Object.entries(metadata.fields)
-            : Object.entries(options.select).filter(([field, enabled]) => field !== "json" && enabled === true).map(([field]) => [field, metadata.fields[field]]);
+        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 = metadata.fields[projection.field];
+            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[]`;
@@ -87,9 +87,7 @@ function compileProfileIncludes(source, parentAlias, include, profile, addValue)
         });
         if (requested.length === 0 && jsonSelections.length === 0)
             throw new Error(`Nested ${name}.select must include at least one field`);
-        if (requested.some(([, column]) => column === undefined))
-            throw new Error(`Nested ${name}.select references an unknown field`);
-        const fields = requested.flatMap(([field, column]) => [`'${field}'`, `${alias}."${column}"`]);
+        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]];
@@ -105,6 +103,36 @@ function compileProfileIncludes(source, parentAlias, include, profile, addValue)
     }
     return selected;
 }
+function compileIncludedFields(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 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 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`,
+    };
+    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;
+}
 function compilePhysicalOrderBy(relation, orderBy, alias) {
     if (orderBy === undefined)
         return "";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@distrohelena/canton-typescript-sdk",
-    "version": "0.1.24",
+    "version": "0.1.26",
     "license": "Apache-2.0",
     "type": "module",
     "main": "./dist/index.js",