@haneullabs/codegen 0.1.0 → 0.8.2

package/src/move-module-builder.ts

@@ -19,8 +19,22 @@ import {
 	withComment,
 } from './utils.js';
 import type { Fields, ModuleSummary, Type, TypeParameter } from './types/summary.js';
+import type { FunctionsOption, ImportExtension, TypesOption } from './config.js';
 import { join } from 'node:path';
 
+const IMPORT_MAP = {
+	Transaction: { module: '@haneullabs/haneul/transactions', isType: true },
+	BcsType: { module: '@haneullabs/haneul/bcs', isType: true },
+	bcs: { module: '@haneullabs/haneul/bcs', isType: false },
+	MoveStruct: { module: '~root/../utils/index', isType: false },
+	MoveTuple: { module: '~root/../utils/index', isType: false },
+	MoveEnum: { module: '~root/../utils/index', isType: false },
+	normalizeMoveArguments: { module: '~root/../utils/index', isType: false },
+	RawTransactionArgument: { module: '~root/../utils/index', isType: true },
+} as const;
+
+type ImportName = keyof typeof IMPORT_MAP;
+
 export class MoveModuleBuilder extends FileBuilder {
 	summary: ModuleSummary;
 	#depsDir = './deps';
@@ -29,26 +43,37 @@ export class MoveModuleBuilder extends FileBuilder {
 	#includedFunctions: Set<string> = new Set();
 	#orderedTypes: string[] = [];
 	#mvrNameOrAddress?: string;
+	#importNames: Partial<Record<ImportName, string>> = {};
+	#importExtension: ImportExtension;
+	#includePhantomTypeParameters: boolean;
 
 	constructor({
 		mvrNameOrAddress,
 		summary,
 		addressMappings = {},
+		importExtension = '.js',
+		includePhantomTypeParameters = false,
 	}: {
 		summary: ModuleSummary;
 		addressMappings?: Record<string, string>;
 		mvrNameOrAddress?: string;
+		importExtension?: ImportExtension;
+		includePhantomTypeParameters?: boolean;
 	}) {
 		super();
 		this.summary = summary;
 		this.#addressMappings = addressMappings;
 		this.#mvrNameOrAddress = mvrNameOrAddress;
+		this.#importExtension = importExtension;
+		this.#includePhantomTypeParameters = includePhantomTypeParameters;
 	}
 
 	static async fromSummaryFile(
 		file: string,
 		addressMappings: Record<string, string>,
 		mvrNameOrAddress?: string,
+		importExtension?: ImportExtension,
+		includePhantomTypeParameters?: boolean,
 	) {
 		const summary = JSON.parse(await readFile(file, 'utf-8'));
 
@@ -56,6 +81,8 @@ export class MoveModuleBuilder extends FileBuilder {
 			summary,
 			addressMappings,
 			mvrNameOrAddress,
+			importExtension,
+			includePhantomTypeParameters,
 		});
 	}
 
@@ -74,6 +101,19 @@ export class MoveModuleBuilder extends FileBuilder {
 		}
 	}
 
+	#getImportName(name: ImportName): string {
+		if (!this.#importNames[name]) {
+			const config = IMPORT_MAP[name];
+			const importSpec = config.isType ? `type ${name}` : name;
+			// Add extension for relative imports (utils)
+			const module = config.module.startsWith('~root')
+				? `${config.module}${this.#importExtension}`
+				: config.module;
+			this.#importNames[name] = this.addImport(module, importSpec);
+		}
+		return this.#importNames[name]!;
+	}
+
 	override async getHeader() {
 		if (!this.summary.doc) {
 			return super.getHeader();
@@ -82,26 +122,29 @@ export class MoveModuleBuilder extends FileBuilder {
 		return `${await super.getHeader()}\n\n/*${await formatComment(this.summary.doc)}*/\n\n`;
 	}
 
-	includeAllFunctions({ privateMethods = 'entry' }: { privateMethods?: 'none' | 'entry' | 'all' }) {
-		for (const [name, func] of Object.entries(this.summary.functions)) {
+	includeFunctions(option?: FunctionsOption) {
+		if (option === false) return;
+
+		const filterByVisibility = !Array.isArray(option);
+		const names = Array.isArray(option) ? option : Object.keys(this.summary.functions);
+		const privateFunctions =
+			typeof option === 'object' && filterByVisibility ? (option.private ?? 'entry') : 'entry';
+
+		for (const name of names) {
+			const func = this.summary.functions[name];
+			if (!func) {
+				throw new Error(
+					`Function ${name} not found in ${this.summary.id.address}::${this.summary.id.name}`,
+				);
+			}
+
 			if (func.macro_) {
 				continue;
 			}
 
-			if (func.visibility !== 'Public') {
-				switch (privateMethods) {
-					case 'none':
-						continue;
-					case 'entry':
-						if (!func.entry) {
-							continue;
-						}
-						break;
-					case 'all':
-						break;
-					default:
-						throw new Error(`Unknown privateMethods option: ${privateMethods}`);
-				}
+			if (filterByVisibility && func.visibility !== 'Public') {
+				if (privateFunctions === false) continue;
+				if (privateFunctions === 'entry' && !func.entry) continue;
 			}
 
 			const safeName = getSafeName(camelCase(name));
@@ -134,6 +177,7 @@ export class MoveModuleBuilder extends FileBuilder {
 					format: 'bcs',
 					summary: this.summary,
 					typeParameters: struct.type_parameters,
+					includePhantomTypeParameters: false,
 					resolveAddress: (address) => this.#resolveAddress(address),
 					onDependency: (address, mod, name) => {
 						const builder = moduleBuilders[`${address}::${mod}`];
@@ -157,6 +201,7 @@ export class MoveModuleBuilder extends FileBuilder {
 						format: 'bcs',
 						summary: this.summary,
 						typeParameters: enum_.type_parameters,
+						includePhantomTypeParameters: false,
 						resolveAddress: (address) => this.#resolveAddress(address),
 						onDependency: (address, mod, name) => {
 							const builder = moduleBuilders[`${address}::${mod}`];
@@ -178,9 +223,16 @@ export class MoveModuleBuilder extends FileBuilder {
 		this.#orderedTypes.push(name);
 	}
 
-	includeAllTypes(moduleBuilders: Record<string, MoveModuleBuilder>) {
-		Object.keys(this.summary.structs).forEach((name) => this.includeType(name, moduleBuilders));
-		Object.keys(this.summary.enums).forEach((name) => this.includeType(name, moduleBuilders));
+	includeTypes(moduleBuilders: Record<string, MoveModuleBuilder>, option?: TypesOption) {
+		if (option === false) return;
+
+		const names = Array.isArray(option)
+			? option
+			: [...Object.keys(this.summary.structs), ...Object.keys(this.summary.enums)];
+
+		for (const name of names) {
+			this.includeType(name, moduleBuilders);
+		}
 	}
 
 	async renderBCSTypes() {
@@ -216,8 +268,9 @@ export class MoveModuleBuilder extends FileBuilder {
 		name: string,
 		{ fields }: Fields,
 		typeParameters: TypeParameter[] = [],
+		includePhantomTypeParameters = false,
 	) {
-		this.addImport('~root/../utils/index.js', 'MoveStruct');
+		const moveStructName = this.#getImportName('MoveStruct');
 		const fieldObject = await mapToObject({
 			items: Object.entries(fields),
 			getComment: ([_name, field]) => field.doc,
@@ -225,18 +278,17 @@ export class MoveModuleBuilder extends FileBuilder {
 				name,
 				renderTypeSignature(field.type_, {
 					format: 'bcs',
-					onBcsType: () => {
-						this.addImport('@haneullabs/haneul/bcs', 'bcs');
-					},
+					bcsImport: () => this.#getImportName('bcs'),
 					summary: this.summary,
 					typeParameters,
+					includePhantomTypeParameters,
 					resolveAddress: (address) => this.#resolveAddress(address),
 					onDependency: (address, mod) => {
 						if (address !== this.summary.id.address || mod !== this.summary.id.name) {
 							return this.addStarImport(
 								address === this.summary.id.address
-									? `./${mod}.js`
-									: join(`~root`, this.#depsDir, `${address}/${mod}.js`),
+									? `./${mod}${this.#importExtension}`
+									: join(`~root`, this.#depsDir, `${address}/${mod}${this.#importExtension}`),
 								mod,
 							);
 						}
@@ -247,30 +299,30 @@ export class MoveModuleBuilder extends FileBuilder {
 			],
 		});
 
-		return parseTS /* ts */ `new MoveStruct({ name: \`${name}\`, fields: ${fieldObject} })`;
+		return parseTS /* ts */ `new ${moveStructName}({ name: \`${name}\`, fields: ${fieldObject} })`;
 	}
 
 	async #renderFieldsAsTuple(
 		name: string,
 		{ fields }: Fields,
 		typeParameters: TypeParameter[] = [],
+		includePhantomTypeParameters = false,
 	) {
-		this.addImport('~root/../utils/index.js', 'MoveTuple');
+		const moveTupleName = this.#getImportName('MoveTuple');
 		const values = Object.values(fields).map((field) =>
 			renderTypeSignature(field.type_, {
 				format: 'bcs',
 				summary: this.summary,
 				typeParameters,
-				onBcsType: () => {
-					this.addImport('@haneullabs/haneul/bcs', 'bcs');
-				},
+				includePhantomTypeParameters,
+				bcsImport: () => this.#getImportName('bcs'),
 				resolveAddress: (address) => this.#resolveAddress(address),
 				onDependency: (address, mod) => {
 					if (address !== this.summary.id.address || mod !== this.summary.id.name) {
 						return this.addStarImport(
 							address === this.summary.id.address
-								? `./${mod}.js`
-								: join(`~root`, this.#depsDir, `${address}/${mod}.js`),
+								? `./${mod}${this.#importExtension}`
+								: join(`~root`, this.#depsDir, `${address}/${mod}${this.#importExtension}`),
 							mod,
 						);
 					}
@@ -280,7 +332,7 @@ export class MoveModuleBuilder extends FileBuilder {
 			}),
 		);
 
-		return parseTS /* ts */ `new MoveTuple({ name: \`${name}\`, fields: [${values.join(', ')}] })`;
+		return parseTS /* ts */ `new ${moveTupleName}({ name: \`${name}\`, fields: [${values.join(', ')}] })`;
 	}
 
 	async renderStruct(name: string) {
@@ -298,23 +350,51 @@ export class MoveModuleBuilder extends FileBuilder {
 
 		this.exports.push(name);
 
-		const params = struct.type_parameters.filter((param) => !param.phantom);
+		const includePhantom = this.#includePhantomTypeParameters;
+		const params = struct.type_parameters
+			.map((param, i) => ({ param, originalIndex: i }))
+			.filter(({ param }) => includePhantom || !param.phantom);
 		const structName = `\${$moduleName}::${name}`;
 
 		if (params.length === 0) {
+			const hasPhantoms = struct.type_parameters.some((p) => p.phantom);
+			const phantomPlaceholders = hasPhantoms
+				? `<${struct.type_parameters.map((p, i) => `phantom ${p.name ?? `T${i}`}`).join(', ')}>`
+				: '';
 			this.statements.push(
 				...parseTS /* ts */ `export const ${name} = ${
 					struct.fields.positional_fields
-						? await this.#renderFieldsAsTuple(structName, struct.fields, struct.type_parameters)
-						: await this.#renderFieldsAsStruct(structName, struct.fields, struct.type_parameters)
+						? await this.#renderFieldsAsTuple(
+								`${structName}${phantomPlaceholders}`,
+								struct.fields,
+								struct.type_parameters,
+								includePhantom,
+							)
+						: await this.#renderFieldsAsStruct(
+								`${structName}${phantomPlaceholders}`,
+								struct.fields,
+								struct.type_parameters,
+								includePhantom,
+							)
 				}`,
 			);
 		} else {
-			this.addImport('@haneullabs/haneul/bcs', 'type BcsType');
+			const bcsTypeName = this.#getImportName('BcsType');
 
-			const typeParams = `...typeParameters: [${params.map((param, i) => param.name ?? `T${i}`).join(', ')}]`;
-			const typeGenerics = `${params.map((param, i) => `${param.name ?? `T${i}`} extends BcsType<any>`).join(', ')}`;
-			const nameGenerics = `${params.map((param, i) => `\${typeParameters[${i}].name as ${param.name ?? `T${i}`}['name']}`).join(', ')}`;
+			const typeParams = `...typeParameters: [${params.map(({ param, originalIndex }) => param.name ?? `T${originalIndex}`).join(', ')}]`;
+			const typeGenerics = `${params.map(({ param, originalIndex }) => `${param.name ?? `T${originalIndex}`} extends ${bcsTypeName}<any>`).join(', ')}`;
+
+			let filteredIndex = 0;
+			const nameGenerics = struct.type_parameters
+				.map((param, i) => {
+					if (!includePhantom && param.phantom) {
+						return `phantom ${param.name ?? `T${i}`}`;
+					}
+					const idx = filteredIndex++;
+					const paramName = param.name ?? `T${idx}`;
+					return `\${typeParameters[${idx}].name as ${paramName}['name']}`;
+				})
+				.join(', ');
 
 			this.statements.push(
 				...(await withComment(
@@ -326,11 +406,13 @@ export class MoveModuleBuilder extends FileBuilder {
 										`${structName}<${nameGenerics}>`,
 										struct.fields,
 										struct.type_parameters,
+										includePhantom,
 									)
 								: await this.#renderFieldsAsStruct(
 										`${structName}<${nameGenerics}>`,
 										struct.fields,
 										struct.type_parameters,
+										includePhantom,
 									)
 						}
 					}`,
@@ -352,7 +434,8 @@ export class MoveModuleBuilder extends FileBuilder {
 			);
 		}
 
-		this.addImport('~root/../utils/index.js', 'MoveEnum');
+		const includePhantom = this.#includePhantomTypeParameters;
+		const moveEnumName = this.#getImportName('MoveEnum');
 		this.exports.push(name);
 
 		const enumName = `\${$moduleName}::${name}`;
@@ -370,16 +453,15 @@ export class MoveModuleBuilder extends FileBuilder {
 									format: 'bcs',
 									summary: this.summary,
 									typeParameters: enumDef.type_parameters,
-									onBcsType: () => {
-										this.addImport('@haneullabs/haneul/bcs', 'bcs');
-									},
+									includePhantomTypeParameters: includePhantom,
+									bcsImport: () => this.#getImportName('bcs'),
 									resolveAddress: (address) => this.#resolveAddress(address),
 									onDependency: (address, mod) => {
 										if (address !== this.summary.id.address || mod !== this.summary.id.name) {
 											return this.addStarImport(
 												address === this.summary.id.address
-													? `./${mod}.js`
-													: `~root/deps/${address}/${mod}.js`,
+													? `./${mod}${this.#importExtension}`
+													: `~root/deps/${address}/${mod}${this.#importExtension}`,
 												mod,
 											);
 										}
@@ -391,37 +473,56 @@ export class MoveModuleBuilder extends FileBuilder {
 									`${name}.${variantName}`,
 									variant.fields,
 									enumDef.type_parameters,
+									includePhantom,
 								)
 						: await this.#renderFieldsAsStruct(
 								`${name}.${variantName}`,
 								variant.fields,
 								enumDef.type_parameters,
+								includePhantom,
 							),
 			],
 		});
 
-		const params = enumDef.type_parameters.filter((param) => !param.phantom);
+		const params = enumDef.type_parameters
+			.map((param, i) => ({ param, originalIndex: i }))
+			.filter(({ param }) => includePhantom || !param.phantom);
 
 		if (params.length === 0) {
+			const hasPhantoms = enumDef.type_parameters.some((p) => p.phantom);
+			const phantomPlaceholders = hasPhantoms
+				? `<${enumDef.type_parameters.map((p, i) => `phantom ${p.name ?? `T${i}`}`).join(', ')}>`
+				: '';
 			this.statements.push(
 				...(await withComment(
 					enumDef,
-					parseTS /* ts */ `export const ${name} = new MoveEnum({ name: \`${enumName}\`, fields: ${variantsObject} })`,
+					parseTS /* ts */ `export const ${name} = new ${moveEnumName}({ name: \`${enumName}${phantomPlaceholders}\`, fields: ${variantsObject} })`,
 				)),
 			);
 		} else {
-			this.addImport('@haneullabs/haneul/bcs', 'type BcsType');
+			const bcsTypeName = this.#getImportName('BcsType');
+
+			const typeParams = `...typeParameters: [${params.map(({ param, originalIndex }) => param.name ?? `T${originalIndex}`).join(', ')}]`;
+			const typeGenerics = `${params.map(({ param, originalIndex }) => `${param.name ?? `T${originalIndex}`} extends ${bcsTypeName}<any>`).join(', ')}`;
 
-			const typeParams = `...typeParameters: [${params.map((param, i) => param.name ?? `T${i}`).join(', ')}]`;
-			const typeGenerics = `${params.map((param, i) => `${param.name ?? `T${i}`} extends BcsType<any>`).join(', ')}`;
-			const nameGenerics = `${params.map((param, i) => `\${typeParameters[${i}].name as ${param.name ?? `T${i}`}['name']}`).join(', ')}`;
+			let filteredIndex = 0;
+			const nameGenerics = enumDef.type_parameters
+				.map((param, i) => {
+					if (!includePhantom && param.phantom) {
+						return `phantom ${param.name ?? `T${i}`}`;
+					}
+					const idx = filteredIndex++;
+					const paramName = param.name ?? `T${idx}`;
+					return `\${typeParameters[${idx}].name as ${paramName}['name']}`;
+				})
+				.join(', ');
 
 			this.statements.push(
 				...(await withComment(
 					enumDef,
 					parseTS /* ts */ `
 					export function ${name}<${typeGenerics}>(${typeParams}) {
-						return new MoveEnum({ name: \`${enumName}<${nameGenerics}>\`, fields: ${variantsObject} })
+						return new ${moveEnumName}({ name: \`${enumName}<${nameGenerics}>\`, fields: ${variantsObject} })
 					}`,
 				)),
 			);
@@ -434,7 +535,8 @@ export class MoveModuleBuilder extends FileBuilder {
 		if (!this.hasFunctions()) {
 			return;
 		}
-		this.addImport('@haneullabs/haneul/transactions', 'type Transaction');
+
+		const transactionTypeName = this.#getImportName('Transaction');
 
 		for (const [name, func] of Object.entries(this.summary.functions)) {
 			if (func.macro_ || !this.#includedFunctions.has(name)) {
@@ -453,51 +555,51 @@ export class MoveModuleBuilder extends FileBuilder {
 					!isWellKnownObjectParameter(param.type_, (address) => this.#resolveAddress(address)),
 			);
 
-			if (parameters.length > 0) {
-				this.addImport('~root/../utils/index.js', 'normalizeMoveArguments');
-			}
+			const normalizeName =
+				parameters.length > 0 ? this.#getImportName('normalizeMoveArguments') : null;
 
 			names.push(fnName);
 
 			const usedTypeParameters = new Set<number | string>();
 
+			const rawTxArgName =
+				requiredParameters.length > 0 ? this.#getImportName('RawTransactionArgument') : null;
+
 			const argumentsTypes = requiredParameters
 				.map((param) =>
 					renderTypeSignature(param.type_, {
 						format: 'typescriptArg',
 						summary: this.summary,
 						typeParameters: func.type_parameters,
+						includePhantomTypeParameters: false,
 						resolveAddress: (address) => this.#resolveAddress(address),
 						onTypeParameter: (typeParameter) => usedTypeParameters.add(typeParameter),
 					}),
 				)
 				.map((type, i) =>
 					requiredParameters[i].name
-						? `${camelCase(requiredParameters[i].name)}: RawTransactionArgument<${type}>`
-						: `RawTransactionArgument<${type}>`,
+						? `${camelCase(requiredParameters[i].name)}: ${rawTxArgName}<${type}>`
+						: `${rawTxArgName}<${type}>`,
 				)
 				.join(',\n');
 
-			if (argumentsTypes.length > 0) {
-				this.addImport('~root/../utils/index.js', 'type RawTransactionArgument');
-			}
-
-			if (usedTypeParameters.size > 0) {
-				this.addImport('@haneullabs/haneul/bcs', 'type BcsType');
-			}
+			const bcsTypeName = usedTypeParameters.size > 0 ? this.#getImportName('BcsType') : null;
 
-			const filteredTypeParameters = func.type_parameters.filter(
-				(param, i) =>
-					usedTypeParameters.has(i) || (param.name && usedTypeParameters.has(param.name)),
-			);
+			const filteredTypeParameters = func.type_parameters
+				.map((param, i) => ({ param, originalIndex: i }))
+				.filter(
+					({ param, originalIndex }) =>
+						usedTypeParameters.has(originalIndex) ||
+						(param.name && usedTypeParameters.has(param.name)),
+				);
 
 			const genericTypes =
 				filteredTypeParameters.length > 0
-					? `<${filteredTypeParameters.map((param, i) => `${param.name ?? `T${i}`} extends BcsType<any>`).join(', ')}>`
+					? `<${filteredTypeParameters.map(({ param, originalIndex }) => `${param.name ?? `T${originalIndex}`} extends ${bcsTypeName}<any>`).join(', ')}>`
 					: '';
 			const genericTypeArgs =
 				filteredTypeParameters.length > 0
-					? `<${filteredTypeParameters.map((param, i) => `${param.name ?? `T${i}`}`).join(', ')}>`
+					? `<${filteredTypeParameters.map(({ param, originalIndex }) => `${param.name ?? `T${originalIndex}`}`).join(', ')}>`
 					: '';
 
 			const argumentsInterface = this.getUnusedName(
@@ -544,19 +646,22 @@ export class MoveModuleBuilder extends FileBuilder {
 									format: 'typeTag',
 									summary: this.summary,
 									typeParameters: func.type_parameters,
+									includePhantomTypeParameters: false,
 									resolveAddress: (address) => this.#resolveAddress(address),
 								}),
 							)
-							.map((tag) => (tag.includes('{') ? `\`${tag}\`` : `'${tag}'`))
+							.map((tag) =>
+								tag === 'null' ? 'null' : tag.includes('{') ? `\`${tag}\`` : `'${tag}'`,
+							)
 							.join(',\n')}
-					] satisfies string[]\n`
+					] satisfies (string | null)[]\n`
 							: ''
 					}${hasAllParameterNames ? `const parameterNames = ${JSON.stringify(requiredParameters.map((param) => camelCase(param.name!)))}\n` : ''}
-					return (tx: Transaction) => tx.moveCall({
+					return (tx: ${transactionTypeName}) => tx.moveCall({
 						package: packageAddress,
 						module: '${this.summary.id.name}',
 						function: '${name}',
-						${parameters.length > 0 ? `arguments: normalizeMoveArguments(options.arguments${argumentsTypes.length > 0 ? '' : ' ?? []'} , argumentsTypes${hasAllParameterNames ? `, parameterNames` : ''}),` : ''}
+						${parameters.length > 0 ? `arguments: ${normalizeName}(options.arguments${argumentsTypes.length > 0 ? '' : ' ?? []'} , argumentsTypes${hasAllParameterNames ? `, parameterNames` : ''}),` : ''}
 						${func.type_parameters.length ? 'typeArguments: options.typeArguments' : ''}
 					})
 				}`,