@0xobelisk/sui-common 1.1.6 → 1.1.7

package/src/codegen/utils/renderMove/generateEvent.ts

@@ -1,110 +1,99 @@
-import {BaseType, EventData, SchemaData, SchemaType} from '../../types';
+import { BaseType, EventData, SchemaData, SchemaType } from '../../types';
 import { formatAndWriteMove } from '../formatAndWrite';
 import {
-	getStructAttrsWithType,
-	getStructAttrs,
-	getStructTypes,
-	getStructAttrsQuery,
+  getStructAttrsWithType,
+  getStructAttrs,
+  getStructTypes,
+  getStructAttrsQuery
 } from './common';
 
-function capitalizeAndRemoveUnderscores(input: string): string {
-	return input
-		.split('_')
-		.map((word, index) => {
-			return index === 0
-				? word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()
-				: word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
-		})
-		.join('');
+// account_not_found => AccountNotFound,
+function toPascalCase(str: string): string {
+  return str
+    .split('_')
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join('');
 }
 
 function convertToSnakeCase(input: string): string {
-	return input
-		.replace(/([A-Z])/g, '_$1')
-		.toLowerCase()
-		.replace(/^_/, '');
+  return input
+    .replace(/([A-Z])/g, '_$1')
+    .toLowerCase()
+    .replace(/^_/, '');
 }
 
-function generateImport(
-	projectName: string,
-	data: Record<string, SchemaData> | null,
-) {
-	if (data != null) {
-		const names = Object.keys(data);
-		return names
-			.map(name => {
-				return `use ${projectName}::${projectName}_${convertToSnakeCase(
-					name,
-				)}::${name};`;
-			})
-			.join('\n');
-	} else {
-		return '';
-	}
+function generateImport(projectName: string, data: Record<string, SchemaData> | null) {
+  if (data != null) {
+    const names = Object.keys(data);
+    return names
+      .map((name) => {
+        return `use ${projectName}::${projectName}_${convertToSnakeCase(name)}::${name};`;
+      })
+      .join('\n');
+  } else {
+    return '';
+  }
 }
 
 export async function generateSchemaEvent(
-	projectName: string,
-	data: Record<string, SchemaData> | null,
-	events: Record<string, EventData>,
-	path: string
+  projectName: string,
+  data: Record<string, SchemaData> | null,
+  events: Record<string, EventData>,
+  path: string
 ) {
-	console.log('\n📦 Starting Schema Event Generation...');
-	for (const key of Object.keys(events)) {
-				const name = key;
-				const fields = events[key];
-				console.log(
-					`     └─ Generating ${name} event: ${fields}`
-				);
+  console.log('\n📦 Starting Schema Event Generation...');
+  for (const key of Object.keys(events)) {
+    const name = key;
+    const fields = events[key];
+    console.log(`     └─ Generating ${name} event: ${fields}`);
 
-				let	code = `module ${projectName}::${projectName}_${convertToSnakeCase(name)}_event {
+    let code = `module ${projectName}::${projectName}_${name}_event {
 						use sui::event;
 						use std::ascii::String;
 						${generateImport(projectName, data)}
 
-                        public struct ${name}Event has copy, drop {
+                        public struct ${toPascalCase(name)}Event has copy, drop {
                                 ${getStructAttrsWithType(fields as Record<string, string>)}
                         }
 
-                        public fun new(${getStructAttrsWithType(fields as Record<string, string>)}): ${name}Event {
-                               ${name}Event {
+                        public fun new(${getStructAttrsWithType(fields as Record<string, string>)}): ${toPascalCase(name)}Event {
+                               ${toPascalCase(name)}Event {
                                    ${getStructAttrs(fields as Record<string, string>)}
                                }
                         }
                         }`;
-				await formatAndWriteMove(
-					code,
-					`${path}/contracts/${projectName}/sources/codegen/data/${convertToSnakeCase(
-						name
-					)}_event.move`,
-					'formatAndWriteMove'
-				);
-			}
+    await formatAndWriteMove(
+      code,
+      `${path}/contracts/${projectName}/sources/codegen/data/${name}_event.move`,
+      'formatAndWriteMove'
+    );
+  }
 
-	let	code = `module ${projectName}::${projectName}_events {
+  let code = `module ${projectName}::${projectName}_events {
 	 	use std::ascii::{String, string};
 	 	${generateImport(projectName, data)}
-		${Object.entries(events).map(([name, fields]) => {
-		return `
-use ${projectName}::${projectName}_${convertToSnakeCase(name)}_event::${name}Event;
-use ${projectName}::${projectName}_${convertToSnakeCase(name)}_event;
-			public fun ${convertToSnakeCase(name)}_event(${getStructAttrsWithType(fields as Record<string, string>)}) {
-			 dubhe::storage_event::emit_set_record<${name}Event, ${name}Event, ${name}Event>(
-				string(b"${convertToSnakeCase(name)}_event"),
+		${Object.entries(events)
+      .map(([name, fields]) => {
+        return `
+use ${projectName}::${projectName}_${name}_event::${toPascalCase(name)}Event;
+use ${projectName}::${projectName}_${name}_event;
+			public fun ${name}_event(${getStructAttrsWithType(fields as Record<string, string>)}) {
+			 dubhe::storage_event::emit_set_record<${toPascalCase(name)}Event, ${toPascalCase(name)}Event, ${toPascalCase(name)}Event>(
+				string(b"${name}_event"),
 				option::none(),
 			  	option::none(),
-			  option::some(${projectName}_${convertToSnakeCase(name)}_event::new(${getStructAttrs(fields as Record<string, string>)}))
+			  option::some(${projectName}_${name}_event::new(${getStructAttrs(fields as Record<string, string>)}))
 			  )
 			}
-		`
-	}).join('\n')}		
-            }`
+		`;
+      })
+      .join('\n')}		
+            }`;
 
-
-	await formatAndWriteMove(
-		code,
-		`${path}/contracts/${projectName}/sources/codegen/events.move`,
-		'formatAndWriteMove'
-	);
-	console.log('✅ Schema Event Generation Complete\n');
-}
+  await formatAndWriteMove(
+    code,
+    `${path}/contracts/${projectName}/sources/codegen/events.move`,
+    'formatAndWriteMove'
+  );
+  console.log('✅ Schema Event Generation Complete\n');
+}

package/src/codegen/utils/renderMove/generateInit.ts

@@ -3,16 +3,11 @@ import { formatAndWriteMove } from '../formatAndWrite';
 import { existsSync } from 'fs';
 import { capitalizeAndRemoveUnderscores } from './generateSchema';
 
-export async function generateInit(
-	config: DubheConfig,
-	srcPrefix: string
-) {
-	console.log('\n📝 Starting Init Generation...');
-	console.log(
-		`  └─ Output path: ${srcPrefix}/contracts/${config.name}/sources/tests/init.move`
-	);
+export async function generateInit(config: DubheConfig, srcPrefix: string) {
+  console.log('\n📝 Starting Init Generation...');
+  console.log(`  └─ Output path: ${srcPrefix}/contracts/${config.name}/sources/tests/init.move`);
 
-		let init_test_code = `module ${config.name}::${config.name}_init_test {
+  let init_test_code = `module ${config.name}::${config.name}_init_test {
     use ${config.name}::${config.name}_dapp_schema::Dapp;
     use sui::clock;
     use sui::test_scenario;
@@ -30,13 +25,13 @@ export async function generateInit(
     }
 }
 `;
-		await formatAndWriteMove(
-			init_test_code,
-			`${srcPrefix}/contracts/${config.name}/sources/tests/init.move`,
-			'formatAndWriteMove'
-		);
+  await formatAndWriteMove(
+    init_test_code,
+    `${srcPrefix}/contracts/${config.name}/sources/tests/init.move`,
+    'formatAndWriteMove'
+  );
 
-	let init_code = `module ${config.name}::${config.name}_genesis {
+  let init_code = `module ${config.name}::${config.name}_genesis {
       use std::ascii::string;
 
   use sui::clock::Clock;
@@ -56,11 +51,11 @@ export async function generateInit(
   }
 }
 `;
-	await formatAndWriteMove(
-		init_code,
-		`${srcPrefix}/contracts/${config.name}/sources/codegen/genesis.move`,
-		'formatAndWriteMove'
-	);
+  await formatAndWriteMove(
+    init_code,
+    `${srcPrefix}/contracts/${config.name}/sources/codegen/genesis.move`,
+    'formatAndWriteMove'
+  );
 
-	console.log('✅ Init Generation Complete\n');
-}
+  console.log('✅ Init Generation Complete\n');
+}