@distrohelena/canton-typescript-sdk 0.1.24 → 0.1.26

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

@@ -0,0 +1,441 @@
+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";
+/** Emits TypeScript declarations for reachable named DAML records, variants, and enums. */
+export class NamedTypeEmitter {
+    nameResolver;
+    constructor(nameResolver = new TypeScriptNameResolver()) {
+        this.nameResolver = nameResolver;
+        void this.nameResolver;
+    }
+    /** Prepares shared package/module output mappings with template emission. */
+    prepareProjectOrThrow(templates, definitions) {
+        this.nameResolver.prepareProjectOrThrow(templates, definitions);
+    }
+    /** Emits one `types.ts` module for every reachable DAML package/module identity. */
+    emitNamedTypeFiles(definitions) {
+        this.nameResolver.prepareProjectOrThrow([], definitions);
+        return this.emitPreparedNamedTypeFiles(definitions);
+    }
+    /** Emits named type files from an already prepared shared name resolver. */
+    emitPreparedNamedTypeFiles(definitions, templateFiles = []) {
+        const modules = this.resolveModulesOrThrow(definitions);
+        const names = this.resolveDefinitionNamesOrThrow(definitions, this.mergeReservedNames(this.getReservedModuleExports(templateFiles), this.getReservedRuntimeBindings(definitions)));
+        const fieldPropertyNames = this.resolveFieldPropertyNames(definitions);
+        return [...modules.values()].map((module) => {
+            const moduleDefinitions = definitions.filter((definition) => definition.identity.packageId === module.packageId
+                && definition.identity.moduleName === module.moduleName);
+            const externalTypeAliases = this.resolveExternalTypeAliases(module, moduleDefinitions, names);
+            const imports = this.emitImports(module, moduleDefinitions, modules, names, externalTypeAliases);
+            return new GeneratedNamedTypeFile({
+                path: module.path,
+                contents: [
+                    ...imports,
+                    ...(imports.length === 0 ? [] : [""]),
+                    ...moduleDefinitions.map((definition) => this.emitDefinition(definition, names, externalTypeAliases, fieldPropertyNames)),
+                    "",
+                ].join("\n"),
+                packageId: module.packageId,
+                moduleName: module.moduleName,
+                namespaceAlias: module.namespaceAlias,
+                exportedTypeNames: moduleDefinitions.map((definition) => this.getDefinitionName(definition, names)),
+                exportedTypeNamesByIdentity: new Map(moduleDefinitions.map((definition) => [
+                    this.getDefinitionKey(definition.identity.packageId, definition.identity.moduleName, definition.identity.name),
+                    this.getDefinitionName(definition, names),
+                ])),
+                fieldPropertyNames: new Map([...fieldPropertyNames.entries()].filter(([key]) => key.startsWith(`${module.key}\u0000`))),
+            });
+        });
+    }
+    emitDefinition(definition, names, externalTypeAliases, fieldPropertyNames) {
+        const name = this.getDefinitionName(definition, names);
+        if (definition.kind === "record") {
+            return [
+                `export interface ${name} {`,
+                ...definition.fields.map((field, index) => `    readonly ${this.getFieldPropertyName(definition, index, fieldPropertyNames)}: ${this.getTypeName(field.type, names, externalTypeAliases)};`),
+                "}",
+            ].join("\n");
+        }
+        else if (definition.kind === "variant") {
+            return [
+                `export type ${name} =`,
+                ...definition.constructors.map((constructor) => `    | { readonly tag: ${JSON.stringify(constructor.constructor)}; readonly value: ${this.getTypeName(constructor.payload, names, externalTypeAliases)}; }`),
+            ].map((line, index, lines) => index === lines.length - 1 ? `${line};` : line).join("\n");
+        }
+        return `export type ${name} = ${definition.constructors.map((constructor) => JSON.stringify(constructor)).join(" | ")};`;
+    }
+    emitImports(module, definitions, modules, names, externalTypeAliases) {
+        const imports = new Map();
+        const runtimeTypes = new Set();
+        for (const definition of definitions) {
+            for (const primitive of this.getRuntimePrimitiveTypes(definition)) {
+                runtimeTypes.add(primitive);
+            }
+            for (const reference of this.getNamedReferences(definition)) {
+                const referencedModuleKey = this.getModuleKey(reference.identity.packageId, reference.identity.moduleName);
+                if (referencedModuleKey === module.key) {
+                    continue;
+                }
+                const referencedModule = modules.get(referencedModuleKey);
+                if (referencedModule === undefined) {
+                    throw new Error(`Cannot emit unresolved named DAML type '${reference.identity.name}'`);
+                }
+                const importPath = this.relativeFilePath(module.path, referencedModule.path);
+                const importedNames = imports.get(importPath) ?? new Map();
+                importedNames.set(this.getNamedReferenceTypeName(reference.identity, names), this.getExternalTypeAlias(reference.identity, externalTypeAliases));
+                imports.set(importPath, importedNames);
+            }
+        }
+        return [
+            ...(runtimeTypes.size === 0 ? [] : [
+                `import type { ${[...runtimeTypes].sort().join(", ")} } from ${JSON.stringify(this.relativeFilePath(module.path, "generated/support/runtime.ts"))};`,
+            ]),
+            ...[...imports.entries()]
+                .sort(([left], [right]) => left.localeCompare(right))
+                .map(([path, importedNames]) => `import type { ${[...importedNames.entries()]
+                .sort(([left], [right]) => left.localeCompare(right))
+                .map(([exportedName, alias]) => `${exportedName} as ${alias}`)
+                .join(", ")} } from ${JSON.stringify(path)};`),
+        ];
+    }
+    resolveExternalTypeAliases(module, definitions, names) {
+        const references = new Map();
+        for (const definition of definitions) {
+            for (const reference of this.getNamedReferences(definition)) {
+                const moduleKey = this.getModuleKey(reference.identity.packageId, reference.identity.moduleName);
+                if (moduleKey !== module.key) {
+                    const key = this.getDefinitionKey(reference.identity.packageId, reference.identity.moduleName, reference.identity.name);
+                    references.set(key, reference.identity);
+                }
+            }
+        }
+        const aliases = new Map();
+        const usedNames = new Set(definitions.map((definition) => this.getDefinitionName(definition, names)));
+        for (const [key, identity] of [...references.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+            const baseName = this.safeTypeName(`${identity.packageId} ${identity.moduleName} ${identity.name}`);
+            let alias = baseName;
+            let escalation = 2;
+            if (usedNames.has(alias)) {
+                alias = `${baseName}_${this.shortHash(key)}`;
+            }
+            while (usedNames.has(alias)) {
+                alias = `${baseName}_${this.shortHash(key)}_${escalation}`;
+                escalation += 1;
+            }
+            usedNames.add(alias);
+            aliases.set(key, alias);
+        }
+        return aliases;
+    }
+    getExternalTypeAlias(identity, aliases) {
+        const alias = aliases.get(this.getDefinitionKey(identity.packageId, identity.moduleName, identity.name));
+        if (alias === undefined) {
+            throw new Error(`Cannot resolve external named DAML type '${identity.name}'`);
+        }
+        return alias;
+    }
+    *getNamedReferences(type) {
+        switch (type.kind) {
+            case "namedReference":
+                yield type;
+                return;
+            case "contractId": return;
+            case "optional":
+            case "list":
+                yield* this.getNamedReferences(type.element);
+                return;
+            case "textMap":
+                yield* this.getNamedReferences(type.value);
+                return;
+            case "genMap":
+                yield* this.getNamedReferences(type.key);
+                yield* this.getNamedReferences(type.value);
+                return;
+            case "record":
+                for (const field of type.fields) {
+                    yield* this.getNamedReferences(field.type);
+                }
+                return;
+            case "variant":
+                for (const constructor of type.constructors) {
+                    yield* this.getNamedReferences(constructor.payload);
+                }
+                return;
+            case "primitive":
+            case "enum":
+                return;
+        }
+    }
+    getTypeName(type, names, externalTypeAliases) {
+        switch (type.kind) {
+            case "primitive":
+                return this.getPrimitiveTypeName(type.builtinType);
+            case "contractId":
+                return "string";
+            case "optional":
+                return `${this.getTypeName(type.element, names, externalTypeAliases)} | undefined`;
+            case "list":
+                return `readonly ${this.getTypeName(type.element, names, externalTypeAliases)}[]`;
+            case "textMap":
+                return `ReadonlyMap<string, ${this.getTypeName(type.value, names, externalTypeAliases)}>`;
+            case "genMap":
+                return `ReadonlyMap<${this.getTypeName(type.key, names, externalTypeAliases)}, ${this.getTypeName(type.value, names, externalTypeAliases)}>`;
+            case "record":
+            case "variant":
+            case "enum":
+                throw new Error("Named DAML declarations must not contain anonymous record, variant, or enum shapes");
+            case "namedReference":
+                return externalTypeAliases.get(this.getDefinitionKey(type.identity.packageId, type.identity.moduleName, type.identity.name)) ?? this.getNamedReferenceTypeName(type.identity, names);
+        }
+    }
+    getPrimitiveTypeName(type) {
+        switch (type) {
+            case DamlLfBuiltinType.unit:
+                return "DamlUnit";
+            case DamlLfBuiltinType.bool:
+                return "boolean";
+            case DamlLfBuiltinType.int64:
+                return "bigint";
+            case DamlLfBuiltinType.date:
+                return "DamlDate";
+            case DamlLfBuiltinType.timestamp:
+                return "DamlTimestamp";
+            case DamlLfBuiltinType.numeric:
+                return "DamlNumeric";
+            case DamlLfBuiltinType.party:
+                return "DamlParty";
+            case DamlLfBuiltinType.text:
+                return "string";
+            default:
+                throw new Error(`Cannot emit unsupported primitive DAML type '${type}'`);
+        }
+    }
+    resolveModulesOrThrow(definitions) {
+        const identities = new Map();
+        for (const definition of definitions) {
+            const key = this.getModuleKey(definition.identity.packageId, definition.identity.moduleName);
+            identities.set(key, {
+                packageId: definition.identity.packageId,
+                moduleName: definition.identity.moduleName,
+            });
+        }
+        return new Map([...identities.entries()].map(([key, identity]) => [
+            key,
+            {
+                ...identity,
+                key,
+                path: `${this.nameResolver.getNamedTypeModuleDirectoryPath(identity.packageId, identity.moduleName)}/types.ts`,
+                namespaceAlias: this.nameResolver.getNamedTypeModuleNamespaceAlias(identity.packageId, identity.moduleName),
+            },
+        ]));
+    }
+    resolveDefinitionNamesOrThrow(definitions, reservedNamesByModule) {
+        const values = definitions.map((definition) => [
+            this.getDefinitionKey(definition.identity.packageId, definition.identity.moduleName, definition.identity.name),
+            definition,
+        ]);
+        const duplicate = new Set();
+        for (const [key] of values) {
+            if (duplicate.has(key)) {
+                throw new Error(`Cannot emit duplicate named DAML type '${key.replaceAll("\u0000", ":")}'`);
+            }
+            duplicate.add(key);
+        }
+        const resolvedNames = this.resolveCollisionSafeNames(values, ([, definition]) => this.safeTypeName(definition.identity.name), ([, definition]) => this.getModuleKey(definition.identity.packageId, definition.identity.moduleName), "_", reservedNamesByModule);
+        return new Map(values.map((value) => [
+            value[0],
+            resolvedNames.get(value),
+        ]));
+    }
+    resolveCollisionSafeNames(values, getBaseName, getScope, collisionSeparator = "_", reservedNamesByScope = new Map()) {
+        const counts = new Map();
+        for (const value of values) {
+            const key = `${getScope(value)}\u0000${getBaseName(value)}`;
+            counts.set(key, (counts.get(key) ?? 0) + 1);
+        }
+        const names = new Map();
+        const allocated = new Map();
+        for (const value of [...values].sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)))) {
+            const scope = getScope(value);
+            const baseName = getBaseName(value);
+            const groupKey = `${scope}\u0000${baseName}`;
+            const suffix = counts.get(groupKey) === 1 ? "" : `${collisionSeparator}${this.shortHash(JSON.stringify(value))}`;
+            const baseCandidate = `${baseName}${suffix}`;
+            const used = allocated.get(scope) ?? new Set(reservedNamesByScope.get(scope));
+            let candidate = used.has(baseCandidate) ? `${baseCandidate}Type` : baseCandidate;
+            let escalation = 2;
+            while (used.has(candidate)) {
+                candidate = `${baseCandidate}_${escalation}`;
+                escalation += 1;
+            }
+            used.add(candidate);
+            allocated.set(scope, used);
+            names.set(value, candidate);
+        }
+        return names;
+    }
+    getReservedModuleExports(templateFiles) {
+        const exportsByModule = new Map();
+        for (const file of templateFiles) {
+            const binding = file.binding;
+            const moduleKey = this.getModuleKeyFromTemplateIdentity(binding.templateIdentityKey);
+            const exports = exportsByModule.get(moduleKey) ?? new Set();
+            exports.add(binding.className);
+            exports.add(binding.createFieldsTypeName);
+            exports.add(binding.createdEventTypeName);
+            for (const choice of binding.choices) {
+                exports.add(choice.choiceTypeName);
+                exports.add(choice.exercisedEventTypeName);
+            }
+            exportsByModule.set(moduleKey, exports);
+        }
+        return exportsByModule;
+    }
+    getReservedRuntimeBindings(definitions) {
+        const bindings = new Set([
+            "DamlDate",
+            "DamlNumeric",
+            "DamlParty",
+            "DamlTimestamp",
+            "DamlUnit",
+        ]);
+        return new Map([...new Set(definitions.map((definition) => this.getModuleKey(definition.identity.packageId, definition.identity.moduleName)))].map((moduleKey) => [
+            moduleKey,
+            bindings,
+        ]));
+    }
+    mergeReservedNames(...reservations) {
+        const merged = new Map();
+        for (const reservation of reservations) {
+            for (const [moduleKey, names] of reservation) {
+                const mergedNames = merged.get(moduleKey) ?? new Set();
+                for (const name of names) {
+                    mergedNames.add(name);
+                }
+                merged.set(moduleKey, mergedNames);
+            }
+        }
+        return merged;
+    }
+    resolveFieldPropertyNames(definitions) {
+        const fields = definitions.flatMap((definition) => definition.kind === "record"
+            ? definition.fields.map((field, index) => ({ definition, field, index }))
+            : []);
+        const counts = new Map();
+        for (const item of fields) {
+            const baseName = this.safePropertyName(item.field.propertyName);
+            const groupKey = `${this.getDefinitionKey(item.definition.identity.packageId, item.definition.identity.moduleName, item.definition.identity.name)}\u0000${baseName}`;
+            counts.set(groupKey, (counts.get(groupKey) ?? 0) + 1);
+        }
+        const names = new Map();
+        for (const item of [...fields].sort((left, right) => this.getFieldKey(left.definition, left.index).localeCompare(this.getFieldKey(right.definition, right.index)))) {
+            const baseName = this.safePropertyName(item.field.propertyName);
+            const definitionKey = this.getDefinitionKey(item.definition.identity.packageId, item.definition.identity.moduleName, item.definition.identity.name);
+            const groupKey = `${definitionKey}\u0000${baseName}`;
+            const name = counts.get(groupKey) === 1
+                ? baseName
+                : `${baseName}_${this.shortHash(this.getFieldKey(item.definition, item.index))}`;
+            names.set(this.getFieldKey(item.definition, item.index), name);
+        }
+        return names;
+    }
+    getFieldPropertyName(definition, index, names) {
+        const name = names.get(this.getFieldKey(definition, index));
+        if (name === undefined) {
+            throw new Error(`Cannot resolve property name for named DAML type '${definition.identity.name}'`);
+        }
+        return name;
+    }
+    getFieldKey(definition, index) {
+        return `${this.getDefinitionKey(definition.identity.packageId, definition.identity.moduleName, definition.identity.name)}\u0000field\u0000${index}`;
+    }
+    safePropertyName(value) {
+        const name = value.replace(/[^A-Za-z0-9_$]/g, "_");
+        if (name.length === 0) {
+            return "field";
+        }
+        return /^[0-9]/.test(name) ? `_${name}` : name;
+    }
+    getModuleKeyFromTemplateIdentity(identityKey) {
+        const [packageId, moduleName] = identityKey.split("\u0000");
+        return this.getModuleKey(packageId, moduleName);
+    }
+    relativeFilePath(fromPath, toPath) {
+        const from = fromPath.split("/").slice(0, -1);
+        const to = toPath.split("/");
+        while (from[0] === to[0] && from.length > 0) {
+            from.shift();
+            to.shift();
+        }
+        const relativePath = from.map(() => "..").concat(to).join("/") || ".";
+        return `${relativePath.startsWith(".") ? relativePath : `./${relativePath}`}`.replace(/\.ts$/, ".js");
+    }
+    getDefinitionName(definition, names) {
+        return this.getNamedReferenceTypeName(definition.identity, names);
+    }
+    getNamedReferenceTypeName(identity, names) {
+        const name = names.get(this.getDefinitionKey(identity.packageId, identity.moduleName, identity.name));
+        if (name === undefined) {
+            throw new Error(`Cannot emit unresolved named DAML type '${identity.name}'`);
+        }
+        return name;
+    }
+    getModuleKey(packageId, moduleName) {
+        return `${packageId}\u0000${moduleName}`;
+    }
+    getDefinitionKey(packageId, moduleName, name) {
+        return `${this.getModuleKey(packageId, moduleName)}\u0000${name}`;
+    }
+    safeTypeName(value) {
+        const normalized = value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[^A-Za-z0-9]+/g, " ").trim();
+        if (normalized.length === 0) {
+            throw new Error("Cannot normalize an empty DAML identifier");
+        }
+        const name = normalized.split(/\s+/).map((segment) => `${segment[0].toUpperCase()}${segment.slice(1)}`).join("");
+        return /^[0-9]/.test(name) ? `_${name}` : name;
+    }
+    *getRuntimePrimitiveTypes(type) {
+        switch (type.kind) {
+            case "primitive": {
+                const name = this.getPrimitiveTypeName(type.builtinType);
+                if (name.startsWith("Daml")) {
+                    yield name;
+                }
+                return;
+            }
+            case "contractId": return;
+            case "optional":
+            case "list":
+                yield* this.getRuntimePrimitiveTypes(type.element);
+                return;
+            case "textMap":
+                yield* this.getRuntimePrimitiveTypes(type.value);
+                return;
+            case "genMap":
+                yield* this.getRuntimePrimitiveTypes(type.key);
+                yield* this.getRuntimePrimitiveTypes(type.value);
+                return;
+            case "record":
+                for (const field of type.fields) {
+                    yield* this.getRuntimePrimitiveTypes(field.type);
+                }
+                return;
+            case "variant":
+                for (const constructor of type.constructors) {
+                    yield* this.getRuntimePrimitiveTypes(constructor.payload);
+                }
+                return;
+            case "enum":
+            case "namedReference":
+                return;
+        }
+    }
+    shortHash(value) {
+        let hash = 0x811c9dc5;
+        for (const character of value) {
+            hash ^= character.charCodeAt(0);
+            hash = Math.imul(hash, 0x01000193);
+        }
+        return (hash >>> 0).toString(36).padStart(6, "0").slice(-6);
+    }
+}

package/dist/daml-interface/emission/project-emitter.d.ts

@@ -1,13 +1,17 @@
 import { DamlInterfaceAnalysisResult } from "../analysis/daml-interface-analyzer.js";
 import { GeneratedDamlInterfaceProject } from "../emission-model/generated-daml-interface-project.js";
+import { NamedTypeEmitter } from "./named-type-emitter.js";
 import { RegistryEmitter } from "./registry-emitter.js";
 import { SupportFileEmitter } from "./support-file-emitter.js";
 import { TemplateBindingEmitter } from "./template-binding-emitter.js";
+import { TypeScriptNameResolver } from "./type-script-name-resolver.js";
 export declare class ProjectEmitter {
+    private readonly nameResolver;
     private readonly templateBindingEmitter;
     private readonly supportFileEmitter;
     private readonly registryEmitter;
-    constructor(templateBindingEmitter?: TemplateBindingEmitter, supportFileEmitter?: SupportFileEmitter, registryEmitter?: RegistryEmitter);
+    private readonly namedTypeEmitter;
+    constructor(nameResolver?: TypeScriptNameResolver, templateBindingEmitter?: TemplateBindingEmitter, supportFileEmitter?: SupportFileEmitter, registryEmitter?: RegistryEmitter, namedTypeEmitter?: NamedTypeEmitter);
     /** Emits the complete in-memory DAML interface project from analyzed templates. */
     emitProject(analysis: DamlInterfaceAnalysisResult): GeneratedDamlInterfaceProject;
 }

package/dist/daml-interface/emission/project-emitter.js

@@ -1,36 +1,53 @@
 import { GeneratedDamlInterfaceProject } from "../emission-model/generated-daml-interface-project.js";
+import { NamedTypeEmitter } from "./named-type-emitter.js";
 import { RegistryEmitter } from "./registry-emitter.js";
 import { SupportFileEmitter } from "./support-file-emitter.js";
 import { TemplateBindingEmitter } from "./template-binding-emitter.js";
+import { TypeScriptNameResolver } from "./type-script-name-resolver.js";
 export class ProjectEmitter {
+    nameResolver;
     templateBindingEmitter;
     supportFileEmitter;
     registryEmitter;
-    constructor(templateBindingEmitter = new TemplateBindingEmitter(), supportFileEmitter = new SupportFileEmitter(), registryEmitter = new RegistryEmitter()) {
+    namedTypeEmitter;
+    constructor(nameResolver = new TypeScriptNameResolver(), templateBindingEmitter = new TemplateBindingEmitter(nameResolver), supportFileEmitter = new SupportFileEmitter(), registryEmitter = new RegistryEmitter(), namedTypeEmitter = new NamedTypeEmitter(nameResolver)) {
+        this.nameResolver = nameResolver;
         this.templateBindingEmitter = templateBindingEmitter;
         this.supportFileEmitter = supportFileEmitter;
         this.registryEmitter = registryEmitter;
+        this.namedTypeEmitter = namedTypeEmitter;
+        void this.nameResolver;
         void this.templateBindingEmitter;
+        void this.namedTypeEmitter;
         void this.supportFileEmitter;
         void this.registryEmitter;
     }
     /** Emits the complete in-memory DAML interface project from analyzed templates. */
     emitProject(analysis) {
-        const templateFiles = analysis.templates.map((template) => this.templateBindingEmitter.emitTemplateFile(template));
-        const supportFiles = this.supportFileEmitter.emitSupportFiles();
+        this.namedTypeEmitter.prepareProjectOrThrow(analysis.templates, analysis.typeDefinitions);
+        const templateBindingFiles = analysis.templates.map((template) => this.templateBindingEmitter.emitTemplateBindingFile(template));
+        const namedTypeFiles = this.namedTypeEmitter.emitPreparedNamedTypeFiles(analysis.typeDefinitions, templateBindingFiles);
+        const templateFiles = analysis.templates.map((template) => this.templateBindingEmitter.emitTemplateFile(template, namedTypeFiles));
+        const supportFiles = [
+            ...this.supportFileEmitter.emitSupportFiles(analysis, namedTypeFiles),
+            ...this.supportFileEmitter.emitNamespaceFiles(new GeneratedDamlInterfaceProject({ templateFiles, namedTypeFiles })),
+        ];
         const baseProject = new GeneratedDamlInterfaceProject({
             templateFiles,
+            namedTypeFiles,
             supportFiles,
         });
         const registryFile = this.registryEmitter.emitRegistry(baseProject);
         const projectWithRegistry = new GeneratedDamlInterfaceProject({
             templateFiles,
+            namedTypeFiles,
             supportFiles,
             registryFile,
         });
         const indexFile = this.supportFileEmitter.emitIndexFile(projectWithRegistry);
         return new GeneratedDamlInterfaceProject({
             templateFiles,
+            namedTypeFiles,
             supportFiles,
             registryFile,
             indexFile,

package/dist/daml-interface/emission/registry-emitter.d.ts

@@ -3,4 +3,5 @@ import { GeneratedRegistryFile } from "../emission-model/generated-registry-file
 export declare class RegistryEmitter {
     /** Emits a registry that dispatches created and exercised events by template id. */
     emitRegistry(project: GeneratedDamlInterfaceProject): GeneratedRegistryFile;
+    private emitCases;
 }

package/dist/daml-interface/emission/registry-emitter.js

@@ -8,27 +8,31 @@ export class RegistryEmitter {
                 .replace(/\.ts$/, ".js");
             return `import { ${file.binding.className} } from "${modulePath}";`;
         });
-        const createdCases = project.templateFiles.map((file) => `            case "${file.binding.templateIdLiteral}":\n                return ${file.binding.className}.decodeCreatedEvent(event);`);
-        const exercisedCases = project.templateFiles.map((file) => `            case "${file.binding.templateIdLiteral}":\n                return ${file.binding.className}.decodeExercisedEvent(event);`);
+        const createdCases = this.emitCases(project, "fromCreatedEvent");
+        const exercisedCases = this.emitCases(project, "fromExercisedEvent");
         return new GeneratedRegistryFile({
             path: "generated/registry.ts",
             contents: [
+                'import { DamlMaterializationError, normalizeDamlCreatedEventSource, normalizeDamlExercisedEventSource } from "@distrohelena/canton-typescript-sdk/daml-interface";',
+                'import type { DamlCreatedEventSource, DamlExercisedEventSource } from "@distrohelena/canton-typescript-sdk/daml-interface";',
                 ...importLines,
                 "",
                 "export class GeneratedRegistry {",
-                "    public static decodeCreatedEvent(templateId: string, event: unknown): unknown {",
-                "        switch (templateId) {",
+                "    public static fromCreatedEvent(event: DamlCreatedEventSource): unknown {",
+                "        const normalized = normalizeDamlCreatedEventSource(event);",
+                "        switch (`${normalized.metadata.templateId.packageId}:${normalized.metadata.templateId.moduleName}:${normalized.metadata.templateId.entityName}`) {",
                 ...createdCases,
                 "            default:",
-                "                return event;",
+                "                throw new DamlMaterializationError(\"template ID\", \"no generated template binding matches the created event\");",
                 "        }",
                 "    }",
                 "",
-                "    public static decodeExercisedEvent(templateId: string, event: unknown): unknown {",
-                "        switch (templateId) {",
+                "    public static fromExercisedEvent(event: DamlExercisedEventSource): unknown {",
+                "        const normalized = normalizeDamlExercisedEventSource(event);",
+                "        switch (`${normalized.metadata.templateId.packageId}:${normalized.metadata.templateId.moduleName}:${normalized.metadata.templateId.entityName}`) {",
                 ...exercisedCases,
                 "            default:",
-                "                return event;",
+                "                throw new DamlMaterializationError(\"template ID\", \"no generated template binding matches the exercised event\");",
                 "        }",
                 "    }",
                 "}",
@@ -36,4 +40,7 @@ export class RegistryEmitter {
             ].join("\n"),
         });
     }
+    emitCases(project, methodName) {
+        return project.templateFiles.map((file) => `            case "${file.binding.templateIdLiteral}":\n                return ${file.binding.className}.${methodName}(event);`);
+    }
 }

package/dist/daml-interface/emission/support-file-emitter.d.ts

@@ -1,8 +1,23 @@
+import { DamlInterfaceAnalysisResult } from "../analysis/daml-interface-analyzer.js";
 import { GeneratedDamlInterfaceProject } from "../emission-model/generated-daml-interface-project.js";
+import { GeneratedNamedTypeFile } from "../emission-model/generated-named-type-file.js";
 import { GeneratedSupportFile } from "../emission-model/generated-support-file.js";
 export declare class SupportFileEmitter {
     /** Emits shared support files for the generated DAML interface project. */
-    emitSupportFiles(): readonly GeneratedSupportFile[];
+    emitSupportFiles(analysis: DamlInterfaceAnalysisResult, namedTypeFiles?: readonly GeneratedNamedTypeFile[]): readonly GeneratedSupportFile[];
+    /** Emits one barrel module for each generated DAML package/module namespace. */
+    emitNamespaceFiles(project: GeneratedDamlInterfaceProject): readonly GeneratedSupportFile[];
     /** Emits the generated project index file. */
     emitIndexFile(project: GeneratedDamlInterfaceProject): GeneratedSupportFile;
+    private getNamespaceGroups;
+    private getFileNameWithoutExtension;
+    private assertDistinctModuleExportedSymbols;
+    private getExportedSymbols;
+    private describeTemplate;
+    private emitDescriptorRegistry;
+    private emitDescriptor;
+    private emitDefinitionDescriptor;
+    private getFieldPropertyName;
+    private getFieldKey;
+    private getIdentityKey;
 }