@aztec/bb.js 0.0.1-alpha.7 → 0.0.1-commit.5476d83

package/dest/node-cjs/cbind/schema_compiler.js

@@ -0,0 +1,607 @@
+"use strict";
+/**
+ * Unified schema compiler with integrated strategies
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaCompiler = void 0;
+exports.createSharedTypesCompiler = createSharedTypesCompiler;
+exports.createSyncApiCompiler = createSyncApiCompiler;
+exports.createAsyncApiCompiler = createAsyncApiCompiler;
+// Helper functions
+function capitalize(s) {
+    return s.charAt(0).toUpperCase() + s.substring(1);
+}
+function camelCase(s) {
+    return s
+        .split('_')
+        .map((part, index) => (index === 0 ? part.charAt(0).toLowerCase() + part.substring(1) : capitalize(part)))
+        .join('');
+}
+function pascalCase(s) {
+    return s.split('_').map(capitalize).join('');
+}
+class SchemaCompiler {
+    config;
+    typeCache = new Map();
+    functionMetadata = [];
+    // WORKTODO(bbapi): AI slop fixup - redundant with typeCache, remove
+    referencedTypes = new Set();
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Process API schema and extract function metadata
+     */
+    processApiSchema(commandsSchema, responsesSchema) {
+        // Process types
+        this.processSchema(commandsSchema);
+        this.processSchema(responsesSchema);
+        // Extract function metadata from named unions
+        if (!Array.isArray(commandsSchema) ||
+            commandsSchema[0] !== 'named_union' ||
+            !Array.isArray(responsesSchema) ||
+            responsesSchema[0] !== 'named_union') {
+            throw new Error('Expected named_union schema format');
+        }
+        const commands = commandsSchema[1];
+        const responses = responsesSchema[1];
+        // Filter out ErrorResponse - it's a special error variant, not a command response
+        const normalResponses = responses.filter(([name]) => name !== 'ErrorResponse');
+        if (commands.length !== normalResponses.length) {
+            throw new Error(`Command count (${commands.length}) does not match response count (${normalResponses.length})`);
+        }
+        for (let i = 0; i < commands.length; i++) {
+            const [commandName] = commands[i];
+            const [responseName] = normalResponses[i];
+            this.functionMetadata.push({
+                name: camelCase(commandName),
+                commandType: pascalCase(commandName),
+                responseType: pascalCase(responseName),
+            });
+        }
+    }
+    /**
+     * Process a schema and populate type cache
+     */
+    processSchema(schema) {
+        const key = this.getSchemaKey(schema);
+        if (this.typeCache.has(key)) {
+            const ret = this.typeCache.get(key);
+            if (ret.typeName === 'unknown') {
+                throw new Error(`Recursive schema detected at ${key}, please check your schema for circular references.`);
+            }
+            return ret;
+        }
+        this.typeCache.set(key, { typeName: 'unknown', msgpackTypeName: '' });
+        const typeInfo = this.generateTypeInfo(schema);
+        this.typeCache.set(key, typeInfo);
+        return typeInfo;
+    }
+    /**
+     * Generate the complete output
+     */
+    compile() {
+        const parts = ['// AUTOGENERATED FILE - DO NOT EDIT', ''];
+        // Generate imports
+        parts.push(...this.generateImports());
+        parts.push('');
+        // Generate type declarations only for 'types' mode
+        if (this.config.mode === 'types') {
+            const sortedTypes = Array.from(this.typeCache.values())
+                .filter(t => t.declaration)
+                .sort((a, b) => a.typeName.localeCompare(b.typeName));
+            // Group declarations
+            const typeAliases = sortedTypes.filter(t => t.declaration?.startsWith('export type') && !t.declaration?.includes('interface'));
+            const publicInterfaces = sortedTypes.filter(t => t.declaration?.includes('export interface'));
+            const privateInterfaces = sortedTypes.filter(t => t.declaration?.includes('interface Msgpack'));
+            // Add type aliases if needed
+            if (typeAliases.length > 0) {
+                parts.push('// Type aliases');
+                for (const type of typeAliases) {
+                    parts.push(type.declaration);
+                }
+                parts.push('');
+            }
+            // Add tuple helper if needed
+            if (this.needsTupleHelper()) {
+                parts.push('// Tuple type for fixed-size arrays', 'type Tuple<T, N extends number> = N extends N ? (number extends N ? T[] : _TupleOf<T, N, []>) : never;', "type _TupleOf<T, N extends number, R extends unknown[]> = R['length'] extends N ? R : _TupleOf<T, N, [T, ...R]>;", '', '// Helper functions', 'function mapTuple<T, S, N extends number>(tuple: Tuple<T, N>, fn: (item: T) => S): Tuple<S, N> {', '  return tuple.map(fn) as Tuple<S, N>;', '}', '');
+            }
+            // Add public interfaces
+            if (publicInterfaces.length > 0) {
+                parts.push('// Public interfaces (exported)');
+                for (const type of publicInterfaces) {
+                    parts.push(type.declaration, '');
+                }
+            }
+            // Add private interfaces
+            if (privateInterfaces.length > 0) {
+                parts.push('// Private Msgpack interfaces (not exported)');
+                for (const type of privateInterfaces) {
+                    parts.push(type.declaration, '');
+                }
+            }
+            // Add conversion functions (only for api_types.ts)
+            const conversions = sortedTypes.filter(t => t.toMethod || t.fromMethod);
+            if (conversions.length > 0) {
+                parts.push('// Conversion functions (exported)');
+                for (const type of conversions) {
+                    if (type.toMethod) {
+                        parts.push('export ' + type.toMethod, '');
+                    }
+                    if (type.fromMethod) {
+                        parts.push('export ' + type.fromMethod, '');
+                    }
+                }
+            }
+            // Add BbApiBase interface
+            if (this.functionMetadata.length > 0) {
+                parts.push('', '// Base API interface');
+                parts.push(this.generateBbApiBaseInterface());
+            }
+        }
+        // Add API class for non-types modes
+        if (this.config.mode !== 'types' && this.functionMetadata.length > 0) {
+            parts.push(this.generateApiClass());
+        }
+        return parts.join('\n') + '\n';
+    }
+    getSchemaKey(schema) {
+        if (typeof schema === 'string')
+            return schema;
+        if (Array.isArray(schema))
+            return JSON.stringify(schema);
+        if (typeof schema === 'object')
+            return schema.__typename || JSON.stringify(schema);
+        return String(schema);
+    }
+    needsTupleHelper() {
+        return Array.from(this.typeCache.values()).some(t => t.typeName.includes('Tuple<'));
+    }
+    trackTypeUsage(typeName) {
+        // Only track for API modes
+        if (this.config.mode === 'types')
+            return;
+        // Extract base types from complex types
+        const baseTypes = this.extractBaseTypes(typeName);
+        for (const type of baseTypes) {
+            // Skip built-in types
+            if (['string', 'number', 'boolean', 'Uint8Array'].includes(type)) {
+                continue;
+            }
+            this.referencedTypes.add(type);
+        }
+    }
+    extractBaseTypes(typeName) {
+        const types = [];
+        // Handle arrays
+        const arrayMatch = typeName.match(/^(.+)\[\]$/);
+        if (arrayMatch) {
+            types.push(...this.extractBaseTypes(arrayMatch[1]));
+            return types;
+        }
+        // Handle Tuple
+        const tupleMatch = typeName.match(/^Tuple<(.+),\s*\d+>$/);
+        if (tupleMatch) {
+            types.push(...this.extractBaseTypes(tupleMatch[1]));
+            return types;
+        }
+        // Handle Record
+        const recordMatch = typeName.match(/^Record<(.+),\s*(.+)>$/);
+        if (recordMatch) {
+            types.push(...this.extractBaseTypes(recordMatch[1]));
+            types.push(...this.extractBaseTypes(recordMatch[2]));
+            return types;
+        }
+        // Handle union types
+        if (typeName.includes(' | ')) {
+            const parts = typeName.split(' | ');
+            for (const part of parts) {
+                types.push(...this.extractBaseTypes(part.trim()));
+            }
+            return types;
+        }
+        // Base case - simple type
+        types.push(typeName);
+        return types;
+    }
+    generateTypeInfo(schema) {
+        if (Array.isArray(schema)) {
+            return this.processArraySchema(schema);
+        }
+        else if (typeof schema === 'string') {
+            return this.processPrimitiveSchema(schema);
+        }
+        else if (typeof schema === 'object') {
+            return this.processObjectSchema(schema);
+        }
+        throw new Error(`Unsupported schema type: ${schema}`);
+    }
+    processArraySchema(schema) {
+        const [type, ...args] = schema;
+        switch (type) {
+            case 'array': {
+                const [subtype, size] = args[0];
+                // Special case: byte arrays should be Uint8Array
+                if (subtype === 'unsigned char') {
+                    return { typeName: 'Uint8Array' };
+                }
+                // For other types, use T[] - idiomatic TypeScript for fixed-length homogeneous arrays
+                const subtypeInfo = this.processSchema(subtype);
+                return {
+                    typeName: `${subtypeInfo.typeName}[]`,
+                    msgpackTypeName: `${subtypeInfo.msgpackTypeName || subtypeInfo.typeName}[]`,
+                };
+            }
+            case 'variant': {
+                const variants = args[0];
+                const variantInfos = variants.map(v => this.processSchema(v));
+                const typeName = variantInfos.map(v => v.typeName).join(' | ');
+                const msgpackUnion = variantInfos.map(v => v.msgpackTypeName || v.typeName).join(' | ');
+                return {
+                    typeName,
+                    msgpackTypeName: `[number, ${msgpackUnion}]`,
+                };
+            }
+            case 'named_union': {
+                const namedTypes = args[0];
+                const tupleTypes = [];
+                for (const [name, schemaOrName] of namedTypes) {
+                    let typeInfo = this.processSchema(schemaOrName);
+                    // Track usage of the type
+                    this.trackTypeUsage(typeInfo.typeName);
+                    tupleTypes.push(`["${name}", ${typeInfo.typeName}]`);
+                }
+                return {
+                    typeName: tupleTypes.join(' | '),
+                    msgpackTypeName: tupleTypes.join(' | '),
+                };
+            }
+            case 'vector': {
+                const [subtype] = args[0];
+                if (subtype === 'unsigned char') {
+                    return { typeName: 'Uint8Array' };
+                }
+                const subtypeInfo = this.processSchema(subtype);
+                return {
+                    typeName: `${subtypeInfo.typeName}[]`,
+                    msgpackTypeName: `${subtypeInfo.msgpackTypeName || subtypeInfo.typeName}[]`,
+                };
+            }
+            case 'alias': {
+                const [rawTypeName, msgpackName] = args[0];
+                const typeName = pascalCase(rawTypeName);
+                let targetType;
+                if (msgpackName.startsWith('bin')) {
+                    targetType = 'Uint8Array';
+                }
+                else if (['int', 'unsigned int', 'unsigned short'].includes(msgpackName)) {
+                    targetType = 'number';
+                }
+                else {
+                    throw new Error(`Unsupported alias type: ${msgpackName}`);
+                }
+                // Create a proper type alias declaration
+                return {
+                    typeName,
+                    msgpackTypeName: targetType,
+                    declaration: `export type ${typeName} = ${targetType};`,
+                };
+            }
+            case 'shared_ptr': {
+                const [subtype] = args[0];
+                return this.processSchema(subtype);
+            }
+            case 'map': {
+                const [keyType, valueType] = args[0];
+                const keyInfo = this.processSchema(keyType);
+                const valueInfo = this.processSchema(valueType);
+                return {
+                    typeName: `Record<${keyInfo.typeName}, ${valueInfo.typeName}>`,
+                    msgpackTypeName: `Record<${keyInfo.msgpackTypeName || keyInfo.typeName}, ${valueInfo.msgpackTypeName || valueInfo.typeName}>`,
+                };
+            }
+            default:
+                throw new Error(`Unsupported array schema type: ${type}`);
+        }
+    }
+    processPrimitiveSchema(schema) {
+        switch (schema) {
+            case 'bool':
+                return { typeName: 'boolean' };
+            case 'int':
+            case 'unsigned int':
+            case 'unsigned short':
+            case 'unsigned long':
+            case 'unsigned char':
+            case 'double':
+                return { typeName: 'number' };
+            case 'string':
+                return { typeName: 'string' };
+            case 'bin32':
+                return { typeName: 'Uint8Array' };
+            case 'field2':
+                // field2 is an extension field type (fq2) represented as a tuple of two Uint8Arrays
+                return {
+                    typeName: 'Field2',
+                    msgpackTypeName: '[Uint8Array, Uint8Array]',
+                    declaration: 'export type Field2 = [Uint8Array, Uint8Array];',
+                };
+            default:
+                return { typeName: pascalCase(schema) };
+        }
+    }
+    processObjectSchema(schema) {
+        const typeName = pascalCase(schema.__typename);
+        const msgpackTypeName = 'Msgpack' + typeName;
+        const declaration = this.generateInterfaces(typeName, schema);
+        const toMethod = this.generateToMethod(typeName, schema);
+        const fromMethod = this.generateFromMethod(typeName, schema);
+        return {
+            typeName,
+            msgpackTypeName,
+            declaration,
+            toMethod,
+            fromMethod,
+        };
+    }
+    getOrCreateEmptyType(typeName) {
+        const key = `empty_${typeName}`;
+        if (this.typeCache.has(key)) {
+            return this.typeCache.get(key);
+        }
+        const typeInfo = {
+            typeName,
+            msgpackTypeName: 'Msgpack' + typeName,
+            declaration: `export interface ${typeName} {}\n\ninterface Msgpack${typeName} {}`,
+            toMethod: `function to${typeName}(o: Msgpack${typeName}): ${typeName} {\n  return {};\n}`,
+            fromMethod: `function from${typeName}(o: ${typeName}): Msgpack${typeName} {\n  return {};\n}`,
+        };
+        this.typeCache.set(key, typeInfo);
+        return typeInfo;
+    }
+    generateInterfaces(name, schema) {
+        const publicInterface = this.generatePublicInterface(name, schema);
+        const msgpackInterface = this.generateMsgpackInterface(name, schema);
+        return publicInterface + '\n\n' + msgpackInterface;
+    }
+    generatePublicInterface(name, schema) {
+        let result = `export interface ${name} {\n`;
+        for (const [key, value] of Object.entries(schema)) {
+            if (key === '__typename')
+                continue;
+            const typeInfo = this.processSchema(value);
+            // Track type usage
+            this.trackTypeUsage(typeInfo.typeName);
+            result += `  ${camelCase(key)}: ${typeInfo.typeName};\n`;
+        }
+        result += '}';
+        return result;
+    }
+    generateMsgpackInterface(name, schema) {
+        let result = `interface Msgpack${name} {\n`;
+        for (const [key, value] of Object.entries(schema)) {
+            if (key === '__typename')
+                continue;
+            const typeInfo = this.processSchema(value);
+            result += `  ${key}: ${typeInfo.msgpackTypeName || typeInfo.typeName};\n`;
+        }
+        result += '}';
+        return result;
+    }
+    generateToMethod(name, schema) {
+        const fields = Object.entries(schema).filter(([key]) => key !== '__typename');
+        if (fields.length === 0) {
+            return `function to${name}(o: Msgpack${name}): ${name} {\n  return {};\n}`;
+        }
+        const checks = fields
+            .map(([key]) => `  if (o.${key} === undefined) { throw new Error("Expected ${key} in ${name} deserialization"); }`)
+            .join('\n');
+        const conversions = fields
+            .map(([key, value]) => {
+            const typeInfo = this.processSchema(value);
+            const converter = this.generateConverter(typeInfo, `o.${key}`, 'to');
+            return `    ${camelCase(key)}: ${converter},`;
+        })
+            .join('\n');
+        return `function to${name}(o: Msgpack${name}): ${name} {
+${checks};
+  return {
+${conversions}
+  };
+}`;
+    }
+    generateFromMethod(name, schema) {
+        const fields = Object.entries(schema).filter(([key]) => key !== '__typename');
+        if (fields.length === 0) {
+            return `function from${name}(o: ${name}): Msgpack${name} {\n  return {};\n}`;
+        }
+        const checks = fields
+            .map(([key]) => `  if (o.${camelCase(key)} === undefined) { throw new Error("Expected ${camelCase(key)} in ${name} serialization"); }`)
+            .join('\n');
+        const conversions = fields
+            .map(([key, value]) => {
+            const typeInfo = this.processSchema(value);
+            const converter = this.generateConverter(typeInfo, `o.${camelCase(key)}`, 'from');
+            return `  ${key}: ${converter},`;
+        })
+            .join('\n');
+        return `function from${name}(o: ${name}): Msgpack${name} {
+${checks};
+  return {
+${conversions}
+  };
+}`;
+    }
+    generateConverter(typeInfo, value, direction) {
+        // Handle arrays/tuples
+        if (typeInfo.typeName.includes('[]') || typeInfo.typeName.includes('Tuple<')) {
+            const elementType = typeInfo.typeName.match(/^(.+)\[\]$/) || typeInfo.typeName.match(/^Tuple<(.+),/);
+            if (elementType) {
+                const isTuple = typeInfo.typeName.includes('Tuple<');
+                const mapFn = isTuple ? 'mapTuple' : 'map';
+                return `${value}.${mapFn}((v: any) => v)`; // Simplified for now
+            }
+        }
+        // Handle custom types that have conversion methods (not just type aliases)
+        if (typeInfo.toMethod || typeInfo.fromMethod) {
+            return `${direction}${typeInfo.typeName}(${value})`;
+        }
+        return value;
+    }
+    generateImports() {
+        const imports = [];
+        // Base imports
+        if (this.config.imports) {
+            imports.push(...this.config.imports);
+        }
+        // For API modes, import from api_types
+        if (this.config.mode !== 'types') {
+            const neededImports = new Set();
+            // Add types and conversion functions from function metadata
+            for (const metadata of this.functionMetadata) {
+                neededImports.add(metadata.commandType);
+                neededImports.add(metadata.responseType);
+                neededImports.add(`from${metadata.commandType}`);
+                neededImports.add(`to${metadata.responseType}`);
+            }
+            // Add referenced types
+            for (const type of this.referencedTypes) {
+                neededImports.add(type);
+            }
+            // Add BbApiBase interface
+            neededImports.add('BbApiBase');
+            if (neededImports.size > 0) {
+                const sortedImports = Array.from(neededImports).sort();
+                // Remove duplicates
+                const uniqueImports = sortedImports.filter((item, index) => sortedImports.indexOf(item) === index);
+                imports.push(`import { ${uniqueImports.join(', ')} } from './api_types.js';`);
+            }
+        }
+        return imports;
+    }
+    generateBbApiBaseInterface() {
+        const methods = this.functionMetadata
+            .map(m => `  ${m.name}(command: ${m.commandType}): Promise<${m.responseType}>;`)
+            .join('\n');
+        return `export interface BbApiBase {
+${methods}
+  destroy(): Promise<void>;
+}`;
+    }
+    generateApiClass() {
+        const className = this.getApiClassName();
+        const methods = this.functionMetadata.map(m => this.generateApiMethod(m)).join('\n\n');
+        // For sync API, don't implement BbApiBase since methods are synchronous
+        const implementsClause = this.config.mode === 'sync' ? '' : ' implements BbApiBase';
+        // For tracing all calls to bb.
+        // const msgpackCallHelper =
+        //   `${this.config.mode === 'async' ? 'async ' : ''}function msgpackCall(backend: ${this.getBackendType()}, input: any[]) {\n` +
+        //   `  const commandName = input[0]?.[0] || 'unknown';\n` +
+        //   `  process.stderr.write(\`[BB MSGPACK ${this.config.mode === 'async' ? 'ASYNC' : 'SYNC'}] \${commandName}\\n\`);\n` +
+        //   `  const inputBuffer = new Encoder({ useRecords: false }).pack(input);\n` +
+        //   `  const encodedResult = ${this.config.mode === 'async' ? 'await ' : ''}backend.call(inputBuffer);\n` +
+        //   `  const result = new Decoder({ useRecords: false }).unpack(encodedResult);\n` +
+        //   `  process.stderr.write(\`[BB MSGPACK ${this.config.mode === 'async' ? 'ASYNC' : 'SYNC'}] \${commandName} => completed\\n\`);\n` +
+        //   `  return result;\n` +
+        //   `}\n`;
+        const msgpackCallHelper = `${this.config.mode === 'async' ? 'async ' : ''}function msgpackCall(backend: ${this.getBackendType()}, input: any[]) {` +
+            `  const inputBuffer = new Encoder({ useRecords: false }).pack(input);` +
+            `  const encodedResult = ${this.config.mode === 'async' ? 'await ' : ''}backend.call(inputBuffer);` +
+            `  return new Decoder({ useRecords: false }).unpack(encodedResult);` +
+            `}\n`;
+        const destroyMethod = this.config.mode === 'sync'
+            ? `  destroy(): void {
+    if (this.backend.destroy) this.backend.destroy();
+  }`
+            : `  destroy(): Promise<void> {
+    return this.backend.destroy ? this.backend.destroy() : Promise.resolve();
+  }`;
+        return (msgpackCallHelper +
+            `export class ${className}${implementsClause} {
+  constructor(protected backend: ${this.getBackendType()}) {}
+
+${methods}
+
+${destroyMethod}
+}`);
+    }
+    getApiClassName() {
+        switch (this.config.mode) {
+            case 'sync':
+                return 'SyncApi';
+            case 'async':
+                return 'AsyncApi';
+            default:
+                throw new Error(`Invalid mode: ${this.config.mode}`);
+        }
+    }
+    getBackendType() {
+        switch (this.config.mode) {
+            case 'sync':
+                return 'IMsgpackBackendSync';
+            case 'async':
+                return 'IMsgpackBackendAsync';
+            default:
+                return '';
+        }
+    }
+    generateApiMethod(metadata) {
+        const { name, commandType, responseType } = metadata;
+        // For async mode, queue immediately and return promise
+        if (this.config.mode === 'async') {
+            return `  ${name}(command: ${commandType}): Promise<${responseType}> {
+    const msgpackCommand = from${commandType}(command);
+    return msgpackCall(this.backend, [["${capitalize(name)}", msgpackCommand]]).then(([variantName, result]: [string, any]) => {
+      if (variantName === 'ErrorResponse') {
+        throw new BBApiException(result.message || 'Unknown error from barretenberg');
+      }
+      if (variantName !== '${responseType}') {
+        throw new BBApiException(\`Expected variant name '${responseType}' but got '\${variantName}'\`);
+      }
+      return to${responseType}(result);
+    });
+  }`;
+        }
+        // For sync mode, keep the synchronous behavior
+        return `  ${name}(command: ${commandType}): ${responseType} {
+    const msgpackCommand = from${commandType}(command);
+    const [variantName, result] = msgpackCall(this.backend, [["${capitalize(name)}", msgpackCommand]]);
+    if (variantName === 'ErrorResponse') {
+      throw new BBApiException(result.message || 'Unknown error from barretenberg');
+    }
+    if (variantName !== '${responseType}') {
+      throw new BBApiException(\`Expected variant name '${responseType}' but got '\${variantName}'\`);
+    }
+    return to${responseType}(result);
+  }`;
+    }
+}
+exports.SchemaCompiler = SchemaCompiler;
+// Factory methods for creating configured compilers
+function createSharedTypesCompiler() {
+    return new SchemaCompiler({
+        mode: 'types',
+        imports: [],
+    });
+}
+function createSyncApiCompiler() {
+    return new SchemaCompiler({
+        mode: 'sync',
+        imports: [
+            `import { IMsgpackBackendSync } from '../../bb_backends/interface.js';`,
+            `import { Decoder, Encoder } from 'msgpackr';`,
+            `import { BBApiException } from '../../bbapi_exception.js';`,
+        ],
+    });
+}
+function createAsyncApiCompiler() {
+    return new SchemaCompiler({
+        mode: 'async',
+        imports: [
+            `import { IMsgpackBackendAsync } from '../../bb_backends/interface.js';`,
+            `import { Decoder, Encoder } from 'msgpackr';`,
+            `import { BBApiException } from '../../bbapi_exception.js';`,
+        ],
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schema_compiler.js","sourceRoot":"","sources":["../../../src/cbind/schema_compiler.ts"],"names":[],"mappings":"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"}