@distrohelena/canton-typescript-sdk 0.1.24 → 0.1.26

package/dist/daml-interface/emission/support-file-emitter.js

@@ -1,23 +1,39 @@
 import { GeneratedSupportFile } from "../emission-model/generated-support-file.js";
 export class SupportFileEmitter {
     /** Emits shared support files for the generated DAML interface project. */
-    emitSupportFiles() {
+    emitSupportFiles(analysis, namedTypeFiles = []) {
         return [
             new GeneratedSupportFile({
                 path: "generated/support/contracts.ts",
                 contents: "export type GeneratedContractId = string;\n",
             }),
             new GeneratedSupportFile({
-                path: "generated/support/decoding.ts",
-                contents: "export function castGeneratedEvent<T>(event: unknown): T {\n    return event as T;\n}\n",
+                path: "generated/support/runtime.ts",
+                contents: [
+                    'export type { DamlDate, DamlNumeric, DamlParty, DamlTimestamp, DamlUnit } from "@distrohelena/canton-typescript-sdk/daml-interface";',
+                    "",
+                ].join("\n"),
             }),
+            this.emitDescriptorRegistry(analysis, namedTypeFiles),
         ];
     }
+    /** Emits one barrel module for each generated DAML package/module namespace. */
+    emitNamespaceFiles(project) {
+        return this.getNamespaceGroups(project).map((group) => new GeneratedSupportFile({
+            path: `${group.directoryPath}/index.ts`,
+            contents: `${[
+                ...(group.namedTypeFile === undefined ? [] : ["export * from \"./types.js\";"]),
+                ...group.templateFiles
+                    .map((file) => this.getFileNameWithoutExtension(file.path))
+                    .map((fileName) => `export * from "./${fileName}.js";`),
+            ].join("\n")}\n`,
+        }));
+    }
     /** Emits the generated project index file. */
     emitIndexFile(project) {
-        const exportLines = project.templateFiles
-            .map((file) => file.path.replace(/^generated\//, "./").replace(/\.ts$/, ".js"))
-            .map((path) => `export * from "${path}";`);
+        const exportLines = this.getNamespaceGroups(project)
+            .map((group) => `export * as ${group.alias} from "${group.directoryPath
+            .replace(/^generated\//, "./")}/index.js";`);
         const lines = [
             ...exportLines,
             'export * from "./registry.js";',
@@ -27,4 +43,188 @@ export class SupportFileEmitter {
             contents: `${lines.join("\n")}\n`,
         });
     }
+    getNamespaceGroups(project) {
+        const groupsByDirectory = new Map();
+        const directoriesByAlias = new Map();
+        for (const templateFile of project.templateFiles) {
+            const directoryPath = templateFile.path.replace(/\/[^/]+$/, "");
+            const alias = templateFile.binding.namespaceAlias;
+            const existingDirectory = directoriesByAlias.get(alias);
+            if (existingDirectory !== undefined && existingDirectory !== directoryPath) {
+                throw new Error(`Cannot emit generated namespace '${alias}' for '${existingDirectory}' and '${directoryPath}'`);
+            }
+            directoriesByAlias.set(alias, directoryPath);
+            const group = groupsByDirectory.get(directoryPath);
+            if (group === undefined) {
+                groupsByDirectory.set(directoryPath, {
+                    alias,
+                    directoryPath,
+                    templateFiles: [templateFile],
+                });
+            }
+            else {
+                group.templateFiles.push(templateFile);
+            }
+        }
+        for (const namedTypeFile of project.namedTypeFiles) {
+            const directoryPath = namedTypeFile.path.replace(/\/[^/]+$/, "");
+            const group = groupsByDirectory.get(directoryPath);
+            if (group === undefined) {
+                groupsByDirectory.set(directoryPath, {
+                    alias: namedTypeFile.namespaceAlias,
+                    directoryPath,
+                    templateFiles: [],
+                    namedTypeFile,
+                });
+            }
+            else if (group.alias !== namedTypeFile.namespaceAlias) {
+                throw new Error(`Cannot emit generated namespace '${group.alias}' and '${namedTypeFile.namespaceAlias}' for '${directoryPath}'`);
+            }
+            else if (group.namedTypeFile !== undefined) {
+                throw new Error(`Cannot emit duplicate named DAML type file for '${directoryPath}'`);
+            }
+            else {
+                group.namedTypeFile = namedTypeFile;
+            }
+        }
+        const groups = [...groupsByDirectory.values()];
+        for (const group of groups) {
+            this.assertDistinctModuleExportedSymbols(group);
+        }
+        return groups;
+    }
+    getFileNameWithoutExtension(path) {
+        return path.slice(path.lastIndexOf("/") + 1).replace(/\.ts$/, "");
+    }
+    assertDistinctModuleExportedSymbols(group) {
+        const descriptionsBySymbol = new Map();
+        for (const file of group.templateFiles) {
+            for (const symbol of this.getExportedSymbols(file)) {
+                const existing = descriptionsBySymbol.get(symbol);
+                if (existing !== undefined) {
+                    throw new Error(`Cannot emit generated module symbol '${symbol}' for `
+                        + `'${existing}' and '${this.describeTemplate(file)}'`);
+                }
+                descriptionsBySymbol.set(symbol, this.describeTemplate(file));
+            }
+        }
+        if (group.namedTypeFile !== undefined) {
+            for (const symbol of group.namedTypeFile.exportedTypeNames) {
+                const existing = descriptionsBySymbol.get(symbol);
+                if (existing !== undefined) {
+                    throw new Error(`Cannot emit generated module symbol '${symbol}' for `
+                        + `'${existing}' and '${group.namedTypeFile.path}'`);
+                }
+                descriptionsBySymbol.set(symbol, group.namedTypeFile.path);
+            }
+        }
+    }
+    getExportedSymbols(file) {
+        return [
+            file.binding.className,
+            file.binding.createFieldsTypeName,
+            file.binding.createdEventTypeName,
+            ...file.binding.choices.flatMap((choice) => [
+                choice.choiceTypeName,
+                choice.exercisedEventTypeName,
+            ]),
+        ];
+    }
+    describeTemplate(file) {
+        return file.binding.templateIdentityKey.replaceAll("\u0000", ":");
+    }
+    emitDescriptorRegistry(analysis, namedTypeFiles) {
+        const identities = new Set();
+        const fieldPropertyNames = new Map();
+        for (const file of namedTypeFiles) {
+            for (const [key, propertyName] of file.fieldPropertyNames) {
+                fieldPropertyNames.set(key, propertyName);
+            }
+        }
+        const factories = analysis.typeDefinitions.map((definition) => {
+            const identityKey = this.getIdentityKey(definition.identity.packageId, definition.identity.moduleName, definition.identity.name);
+            if (identities.has(identityKey)) {
+                throw new Error(`Cannot emit duplicate named DAML type descriptor '${identityKey}'`);
+            }
+            identities.add(identityKey);
+            return [
+                `    ${JSON.stringify(identityKey)}: () => deepFreeze(${this.emitDefinitionDescriptor(definition, fieldPropertyNames)} satisfies DamlTypeDescriptor),`,
+            ].join("");
+        });
+        return new GeneratedSupportFile({
+            path: "generated/support/descriptors.ts",
+            contents: [
+                'import type { DamlTypeDescriptor, DamlTypeDescriptorRegistry } from "@distrohelena/canton-typescript-sdk/daml-interface";',
+                "",
+                "function deepFreeze<T>(value: T): T {",
+                "    if (value !== null && typeof value === \"object\") {",
+                "        for (const child of Object.values(value)) {",
+                "            deepFreeze(child);",
+                "        }",
+                "",
+                "        Object.freeze(value);",
+                "    }",
+                "",
+                "    return value;",
+                "}",
+                "",
+                "const generatedDamlTypeDescriptorFactories: Readonly<Record<string, () => DamlTypeDescriptor>> = Object.freeze({",
+                ...factories,
+                "});",
+                "",
+                "export const generatedDamlTypeDescriptorRegistry: DamlTypeDescriptorRegistry = Object.freeze({",
+                "    resolve(identity) {",
+                "        return generatedDamlTypeDescriptorFactories[`${identity.packageId}:${identity.moduleName}:${identity.entityName}`];",
+                "    },",
+                "});",
+                "",
+            ].join("\n"),
+        });
+    }
+    emitDescriptor(type) {
+        switch (type.kind) {
+            case "primitive":
+                return `{ kind: "primitive", primitive: ${JSON.stringify(type.builtinType)}${type.numericScale === undefined ? "" : `, numericScale: ${type.numericScale}`} }`;
+            case "contractId":
+                return '{ kind: "contractId" }';
+            case "optional":
+                return `{ kind: "optional", element: ${this.emitDescriptor(type.element)} }`;
+            case "list":
+                return `{ kind: "list", element: ${this.emitDescriptor(type.element)} }`;
+            case "textMap":
+                return `{ kind: "textMap", value: ${this.emitDescriptor(type.value)} }`;
+            case "genMap":
+                return `{ kind: "genMap", key: ${this.emitDescriptor(type.key)}, value: ${this.emitDescriptor(type.value)} }`;
+            case "record":
+                return `{ kind: "record", fields: [${type.fields.map((field) => `{ damlLabel: ${JSON.stringify(field.damlLabel)}, propertyName: ${JSON.stringify(field.propertyName)}, type: ${this.emitDescriptor(field.type)} }`).join(", ")}] }`;
+            case "variant":
+                return `{ kind: "variant", constructors: [${type.constructors.map((constructor) => `{ constructor: ${JSON.stringify(constructor.constructor)}, payload: ${this.emitDescriptor(constructor.payload)} }`).join(", ")}] }`;
+            case "enum":
+                return `{ kind: "enum", constructors: [${type.constructors.map((constructor) => JSON.stringify(constructor)).join(", ")}] }`;
+            case "namedReference":
+                return `{ kind: "namedReference", identity: { packageId: ${JSON.stringify(type.identity.packageId)}, moduleName: ${JSON.stringify(type.identity.moduleName)}, entityName: ${JSON.stringify(type.identity.name)} } }`;
+        }
+    }
+    emitDefinitionDescriptor(definition, fieldPropertyNames) {
+        if (definition.kind !== "record") {
+            return this.emitDescriptor(definition);
+        }
+        return `{ kind: "record", fields: [${definition.fields.map((field, index) => `{ damlLabel: ${JSON.stringify(field.damlLabel)}, propertyName: ${JSON.stringify(this.getFieldPropertyName(definition, index, fieldPropertyNames))}, type: ${this.emitDescriptor(field.type)} }`).join(", ")}] }`;
+    }
+    getFieldPropertyName(definition, index, names) {
+        const name = names.get(this.getFieldKey(definition, index));
+        if (name !== undefined) {
+            return name;
+        }
+        else if (definition.kind !== "record") {
+            throw new Error(`Cannot resolve fields for non-record named DAML type '${definition.identity.name}'`);
+        }
+        return definition.fields[index].propertyName;
+    }
+    getFieldKey(definition, index) {
+        return `${definition.identity.packageId}\u0000${definition.identity.moduleName}\u0000${definition.identity.name}\u0000field\u0000${index}`;
+    }
+    getIdentityKey(packageId, moduleName, entityName) {
+        return `${packageId}:${moduleName}:${entityName}`;
+    }
 }

package/dist/daml-interface/emission/template-binding-emitter.d.ts

@@ -1,11 +1,35 @@
 import { AnalyzedTemplate } from "../analysis/analyzed-template.js";
+import { GeneratedNamedTypeFile } from "../emission-model/generated-named-type-file.js";
 import { GeneratedTemplateBindingFile } from "../emission-model/generated-template-binding-file.js";
 import { TypeScriptNameResolver } from "./type-script-name-resolver.js";
+/** Emits typed contract and exercise-event bindings for analyzed DAML templates. */
 export declare class TemplateBindingEmitter {
     private readonly nameResolver;
     constructor(nameResolver?: TypeScriptNameResolver);
+    /** Prepares stable collision-safe names before emitting a complete project. */
+    prepareTemplatesOrThrow(templates: readonly AnalyzedTemplate[]): void;
     /** Emits a generated TypeScript file for one analyzed DAML template. */
-    emitTemplateFile(template: AnalyzedTemplate): GeneratedTemplateBindingFile;
+    emitTemplateFile(template: AnalyzedTemplate, namedTypeFiles?: readonly GeneratedNamedTypeFile[]): GeneratedTemplateBindingFile;
+    /** Emits binding metadata without source, for resolving named declaration exports first. */
+    emitTemplateBindingFile(template: AnalyzedTemplate): GeneratedTemplateBindingFile;
     private createBinding;
     private emitContents;
+    private emitImports;
+    private emitTemplateClass;
+    private emitChoiceEventClass;
+    private emitTemplateDescriptor;
+    private emitDescriptor;
+    private getTypeName;
+    private getPrimitiveTypeName;
+    private normalizeType;
+    private resolveNamedReferences;
+    private walkNamedReferences;
+    private getNamedReference;
+    private getNamedReferenceKey;
+    private toTypeName;
+    private shortHash;
+    private packageId;
+    private moduleName;
+    private entityName;
+    private relativeFilePath;
 }