@distrohelena/canton-typescript-sdk 0.1.53 → 0.1.55

package/dist/cjs/daml-interface/analysis/daml-interface-analyzer.js

@@ -25,6 +25,12 @@ class DamlInterfaceAnalyzer {
         const templates = semanticModel
             .getTemplates()
             .map((item) => this.analyzeTemplateOrThrow(item, typeBuilder));
+        for (const { reference, definition } of semanticModel.getDataTypes()) {
+            if (!definition.serializable) {
+                continue;
+            }
+            typeBuilder.buildDefinitionOrThrow(reference, `data type '${reference.name}'`);
+        }
         return new DamlInterfaceAnalysisResult({
             templates,
             typeDefinitions: typeBuilder.getTypeDefinitions(),
@@ -189,6 +195,13 @@ class AnalyzedDamlTypeBuilder {
                 throw this.unsupported(context, "the type is not serializable");
         }
     }
+    buildDefinitionOrThrow(reference, context) {
+        const key = this.getDefinitionKey(reference);
+        const identity = this.getCanonicalIdentity(reference, key);
+        const dataType = this.getDataTypeOrThrow(reference, context);
+        this.assertSupportedDataTypeParametersOrThrow(dataType, context);
+        this.registerNamedDefinitionOrThrow(reference, identity, dataType);
+    }
     getTypeDefinitions() {
         return Object.freeze(this.definitionKeys.map((key) => {
             const definition = this.definitions.get(key);
@@ -209,17 +222,21 @@ class AnalyzedDamlTypeBuilder {
         this.assertSupportedDataTypeParametersOrThrow(dataType, context);
         this.assertNamedArgumentCountOrThrow(typeArguments, dataType, context);
         const analyzedTypeArguments = Object.freeze(typeArguments.map((argument) => this.buildOrThrow(argument, context, typeParameters)));
-        if (!this.definitions.has(key)) {
-            this.definitionKeys.push(key);
-            this.definitions.set(key, undefined);
-            this.definitions.set(key, this.buildNamedDefinitionOrThrow(reference, identity, dataType));
-        }
+        this.registerNamedDefinitionOrThrow(reference, identity, dataType);
         return Object.freeze({
             kind: "namedReference",
             identity,
             typeArguments: analyzedTypeArguments,
         });
     }
+    registerNamedDefinitionOrThrow(reference, identity, dataType) {
+        const key = this.getDefinitionKey(reference);
+        if (!this.definitions.has(key)) {
+            this.definitionKeys.push(key);
+            this.definitions.set(key, undefined);
+            this.definitions.set(key, this.buildNamedDefinitionOrThrow(reference, identity, dataType));
+        }
+    }
     buildNamedDefinitionOrThrow(reference, identity, dataType) {
         const typeParameters = this.createTypeParameterScope(dataType.typeParameters);
         if (dataType.definition.kind === "record") {

package/dist/cjs/daml-interface/emission/named-type-emitter.js

@@ -5,7 +5,7 @@ const daml_lf_builtin_type_js_1 = require("../../daml-lf/model/daml-lf-builtin-t
 const generated_named_type_file_js_1 = require("../emission-model/generated-named-type-file.js");
 const type_script_name_resolver_js_1 = require("./type-script-name-resolver.js");
 const relative_module_specifier_js_1 = require("./relative-module-specifier.js");
-/** Emits TypeScript declarations for reachable named DAML records, variants, and enums. */
+/** Emits TypeScript declarations for modeled named DAML records, variants, and enums. */
 class NamedTypeEmitter {
     nameResolver;
     constructor(nameResolver = new type_script_name_resolver_js_1.TypeScriptNameResolver()) {
@@ -16,7 +16,7 @@ class NamedTypeEmitter {
     prepareProjectOrThrow(templates, definitions, packageMetadata = new Map()) {
         this.nameResolver.prepareProjectOrThrow(templates, definitions, packageMetadata);
     }
-    /** Emits one `types.ts` module for every reachable DAML package/module identity. */
+    /** Emits one `types.ts` module for every modeled DAML package/module identity. */
     emitNamedTypeFiles(definitions, moduleImportStyle) {
         this.nameResolver.prepareProjectOrThrow([], definitions);
         return this.emitPreparedNamedTypeFiles(definitions, [], moduleImportStyle);

package/dist/cjs/daml-lf/model/daml-lf-data-type.js

@@ -7,6 +7,7 @@ class DamlLfDataType extends daml_lf_definition_js_1.DamlLfDefinition {
     nodeKind = daml_lf_node_kind_js_1.DamlLfNodeKind.dataType;
     definition;
     fields;
+    serializable;
     typeParameters;
     constructor(init) {
         super({
@@ -19,6 +20,7 @@ class DamlLfDataType extends daml_lf_definition_js_1.DamlLfDefinition {
         this.fields = this.definition.kind === "record"
             ? this.definition.fields
             : [];
+        this.serializable = init.serializable ?? true;
         this.typeParameters = Object.freeze((init.typeParameters ?? []).map((parameter) => Object.freeze({
             ...parameter,
             kind: freezeTypeParameterKind(parameter.kind),

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

@@ -236,6 +236,7 @@ class Lf2ModelMapper {
         return new daml_lf_data_type_js_1.DamlLfDataType({
             name: Lf2ModelMapper.resolveInternedDottedName(rawPackage.internedStrings, rawPackage.internedDottedNames, rawDataType.nameInternedDname),
             definition,
+            serializable: rawDataType.serializable,
             typeParameters: rawDataType.params.map((parameter) => Lf2ModelMapper.mapTypeParameter(rawPackage, parameter)),
         });
     }

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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DamlLfSemanticModel = void 0;
+const daml_lf_data_type_js_1 = require("../model/daml-lf-data-type.js");
+const type_con_reference_js_1 = require("../model/type-con-reference.js");
 class DamlLfSemanticModel {
     compilation;
     constructor(compilation) {
@@ -11,6 +13,19 @@ class DamlLfSemanticModel {
     getTemplates() {
         return this.compilation.getTemplates();
     }
+    /** Returns every named data type with its fully qualified identity. */
+    getDataTypes() {
+        return this.compilation.getPackages().flatMap((pkg) => pkg.modules.flatMap((module) => module.definitions
+            .filter((definition) => definition instanceof daml_lf_data_type_js_1.DamlLfDataType)
+            .map((definition) => Object.freeze({
+            reference: Object.freeze(new type_con_reference_js_1.TypeConReference({
+                packageId: pkg.packageId,
+                moduleName: module.name,
+                name: definition.name,
+            })),
+            definition,
+        }))));
+    }
     /** Returns the choices declared on a template identity. */
     getTemplateChoicesOrThrow(templateId) {
         return this.compilation.getTemplateChoicesOrThrow(templateId);

package/dist/daml-interface/analysis/analyzed-daml-type-definition.d.ts

@@ -1,7 +1,7 @@
 import { AnalyzedDamlEnumType, AnalyzedDamlRecordType, AnalyzedDamlVariantType } from "./analyzed-daml-type.js";
 import { DamlLfTypeParameter } from "../../daml-lf/model/daml-lf-data-type.js";
 import { TypeConReference } from "../../daml-lf/model/type-con-reference.js";
-/** A reachable named DAML data type and its complete serializable shape. */
+/** A modeled named DAML data type and its complete serializable shape. */
 export type AnalyzedDamlTypeDefinition = {
     readonly identity: TypeConReference;
 } & ((AnalyzedDamlRecordType & {

package/dist/daml-interface/analysis/daml-interface-analyzer.js

@@ -21,6 +21,12 @@ export class DamlInterfaceAnalyzer {
         const templates = semanticModel
             .getTemplates()
             .map((item) => this.analyzeTemplateOrThrow(item, typeBuilder));
+        for (const { reference, definition } of semanticModel.getDataTypes()) {
+            if (!definition.serializable) {
+                continue;
+            }
+            typeBuilder.buildDefinitionOrThrow(reference, `data type '${reference.name}'`);
+        }
         return new DamlInterfaceAnalysisResult({
             templates,
             typeDefinitions: typeBuilder.getTypeDefinitions(),
@@ -184,6 +190,13 @@ class AnalyzedDamlTypeBuilder {
                 throw this.unsupported(context, "the type is not serializable");
         }
     }
+    buildDefinitionOrThrow(reference, context) {
+        const key = this.getDefinitionKey(reference);
+        const identity = this.getCanonicalIdentity(reference, key);
+        const dataType = this.getDataTypeOrThrow(reference, context);
+        this.assertSupportedDataTypeParametersOrThrow(dataType, context);
+        this.registerNamedDefinitionOrThrow(reference, identity, dataType);
+    }
     getTypeDefinitions() {
         return Object.freeze(this.definitionKeys.map((key) => {
             const definition = this.definitions.get(key);
@@ -204,17 +217,21 @@ class AnalyzedDamlTypeBuilder {
         this.assertSupportedDataTypeParametersOrThrow(dataType, context);
         this.assertNamedArgumentCountOrThrow(typeArguments, dataType, context);
         const analyzedTypeArguments = Object.freeze(typeArguments.map((argument) => this.buildOrThrow(argument, context, typeParameters)));
-        if (!this.definitions.has(key)) {
-            this.definitionKeys.push(key);
-            this.definitions.set(key, undefined);
-            this.definitions.set(key, this.buildNamedDefinitionOrThrow(reference, identity, dataType));
-        }
+        this.registerNamedDefinitionOrThrow(reference, identity, dataType);
         return Object.freeze({
             kind: "namedReference",
             identity,
             typeArguments: analyzedTypeArguments,
         });
     }
+    registerNamedDefinitionOrThrow(reference, identity, dataType) {
+        const key = this.getDefinitionKey(reference);
+        if (!this.definitions.has(key)) {
+            this.definitionKeys.push(key);
+            this.definitions.set(key, undefined);
+            this.definitions.set(key, this.buildNamedDefinitionOrThrow(reference, identity, dataType));
+        }
+    }
     buildNamedDefinitionOrThrow(reference, identity, dataType) {
         const typeParameters = this.createTypeParameterScope(dataType.typeParameters);
         if (dataType.definition.kind === "record") {

package/dist/daml-interface/emission/named-type-emitter.d.ts

@@ -4,13 +4,13 @@ import { GeneratedNamedTypeFile } from "../emission-model/generated-named-type-f
 import { GeneratedTemplateBindingFile } from "../emission-model/generated-template-binding-file.js";
 import { TypeScriptNameResolver } from "./type-script-name-resolver.js";
 import { type DamlModuleImportStyle } from "./daml-module-import-style.js";
-/** Emits TypeScript declarations for reachable named DAML records, variants, and enums. */
+/** Emits TypeScript declarations for modeled named DAML records, variants, and enums. */
 export declare class NamedTypeEmitter {
     private readonly nameResolver;
     constructor(nameResolver?: TypeScriptNameResolver);
     /** Prepares shared package/module output mappings with template emission. */
     prepareProjectOrThrow(templates: readonly import("../analysis/analyzed-template.js").AnalyzedTemplate[], definitions: readonly AnalyzedDamlTypeDefinition[], packageMetadata?: ReadonlyMap<string, DamlInterfacePackageMetadata>): void;
-    /** Emits one `types.ts` module for every reachable DAML package/module identity. */
+    /** Emits one `types.ts` module for every modeled DAML package/module identity. */
     emitNamedTypeFiles(definitions: readonly AnalyzedDamlTypeDefinition[], moduleImportStyle?: DamlModuleImportStyle): readonly GeneratedNamedTypeFile[];
     /** Emits named type files from an already prepared shared name resolver. */
     emitPreparedNamedTypeFiles(definitions: readonly AnalyzedDamlTypeDefinition[], templateFiles?: readonly GeneratedTemplateBindingFile[], moduleImportStyle?: DamlModuleImportStyle): readonly GeneratedNamedTypeFile[];

package/dist/daml-interface/emission/named-type-emitter.js

@@ -2,7 +2,7 @@ import { DamlLfBuiltinType } from "../../daml-lf/model/daml-lf-builtin-type.js";
 import { GeneratedNamedTypeFile } from "../emission-model/generated-named-type-file.js";
 import { TypeScriptNameResolver } from "./type-script-name-resolver.js";
 import { RelativeModuleSpecifier } from "./relative-module-specifier.js";
-/** Emits TypeScript declarations for reachable named DAML records, variants, and enums. */
+/** Emits TypeScript declarations for modeled named DAML records, variants, and enums. */
 export class NamedTypeEmitter {
     nameResolver;
     constructor(nameResolver = new TypeScriptNameResolver()) {
@@ -13,7 +13,7 @@ export class NamedTypeEmitter {
     prepareProjectOrThrow(templates, definitions, packageMetadata = new Map()) {
         this.nameResolver.prepareProjectOrThrow(templates, definitions, packageMetadata);
     }
-    /** Emits one `types.ts` module for every reachable DAML package/module identity. */
+    /** Emits one `types.ts` module for every modeled DAML package/module identity. */
     emitNamedTypeFiles(definitions, moduleImportStyle) {
         this.nameResolver.prepareProjectOrThrow([], definitions);
         return this.emitPreparedNamedTypeFiles(definitions, [], moduleImportStyle);

package/dist/daml-lf/model/daml-lf-data-type.d.ts

@@ -37,11 +37,13 @@ export declare class DamlLfDataType extends DamlLfDefinition {
     readonly nodeKind = DamlLfNodeKind.dataType;
     readonly definition: DamlLfDataTypeDefinition;
     readonly fields: readonly DamlLfField[];
+    readonly serializable: boolean;
     readonly typeParameters: readonly DamlLfTypeParameter[];
     constructor(init: {
         name: string;
         definition?: DamlLfDataTypeDefinition;
         fields?: readonly DamlLfField[];
+        serializable?: boolean;
         typeParameters?: readonly DamlLfTypeParameter[];
     });
 }

package/dist/daml-lf/model/daml-lf-data-type.js

@@ -4,6 +4,7 @@ export class DamlLfDataType extends DamlLfDefinition {
     nodeKind = DamlLfNodeKind.dataType;
     definition;
     fields;
+    serializable;
     typeParameters;
     constructor(init) {
         super({
@@ -16,6 +17,7 @@ export class DamlLfDataType extends DamlLfDefinition {
         this.fields = this.definition.kind === "record"
             ? this.definition.fields
             : [];
+        this.serializable = init.serializable ?? true;
         this.typeParameters = Object.freeze((init.typeParameters ?? []).map((parameter) => Object.freeze({
             ...parameter,
             kind: freezeTypeParameterKind(parameter.kind),

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

@@ -233,6 +233,7 @@ export class Lf2ModelMapper {
         return new DamlLfDataType({
             name: Lf2ModelMapper.resolveInternedDottedName(rawPackage.internedStrings, rawPackage.internedDottedNames, rawDataType.nameInternedDname),
             definition,
+            serializable: rawDataType.serializable,
             typeParameters: rawDataType.params.map((parameter) => Lf2ModelMapper.mapTypeParameter(rawPackage, parameter)),
         });
     }

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

@@ -5,11 +5,17 @@ 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";
 import { TypeConReference } from "../model/type-con-reference.js";
+export type DamlLfDataTypeEntry = {
+    readonly reference: TypeConReference;
+    readonly definition: DamlLfDataType;
+};
 export declare class DamlLfSemanticModel {
     private readonly compilation;
     constructor(compilation: DamlLfCompilation);
     /** Returns the templates exposed by the compiled workspace. */
     getTemplates(): readonly DamlLfTemplate[];
+    /** Returns every named data type with its fully qualified identity. */
+    getDataTypes(): readonly DamlLfDataTypeEntry[];
     /** Returns the choices declared on a template identity. */
     getTemplateChoicesOrThrow(templateId: DamlLfTemplateId): readonly DamlLfChoice[];
     /** Returns the record fields for a resolved type constructor reference. */

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

@@ -1,3 +1,5 @@
+import { DamlLfDataType } from "../model/daml-lf-data-type.js";
+import { TypeConReference } from "../model/type-con-reference.js";
 export class DamlLfSemanticModel {
     compilation;
     constructor(compilation) {
@@ -8,6 +10,19 @@ export class DamlLfSemanticModel {
     getTemplates() {
         return this.compilation.getTemplates();
     }
+    /** Returns every named data type with its fully qualified identity. */
+    getDataTypes() {
+        return this.compilation.getPackages().flatMap((pkg) => pkg.modules.flatMap((module) => module.definitions
+            .filter((definition) => definition instanceof DamlLfDataType)
+            .map((definition) => Object.freeze({
+            reference: Object.freeze(new TypeConReference({
+                packageId: pkg.packageId,
+                moduleName: module.name,
+                name: definition.name,
+            })),
+            definition,
+        }))));
+    }
     /** Returns the choices declared on a template identity. */
     getTemplateChoicesOrThrow(templateId) {
         return this.compilation.getTemplateChoicesOrThrow(templateId);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@distrohelena/canton-typescript-sdk",
-    "version": "0.1.53",
+    "version": "0.1.55",
     "license": "Apache-2.0",
     "type": "module",
     "main": "./dist/index.js",
@@ -87,7 +87,7 @@
     },
     "scripts": {
         "build": "node ./scripts/clean-dist.mjs && tsc -p tsconfig.json && tsc -p tsconfig.cjs.json && node ./scripts/write-cjs-package.mjs",
-        "prepublishOnly": "npm run build && npm run test:unit",
+        "prepublishOnly": "npm run build",
         "generate:daml-interface": "node ./dist/daml-interface/cli/daml-interface-cli-main.js",
         "generate:grpc": "node ./scripts/generate-grpc-bindings.mjs",
         "examples:check": "npm run build && tsc -p tsconfig.examples.json --noEmit",