@0xobelisk/sui-common 1.1.6 → 1.1.8

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

@@ -1,162 +1,138 @@
-import {BaseType, SchemaData, SchemaType} from '../../types';
+import { BaseType, SchemaData, SchemaType } from '../../types';
 import { formatAndWriteMove } from '../formatAndWrite';
 import {
-	getStructAttrsWithType,
-	getStructAttrs,
-	getStructTypes,
-	getStructAttrsQuery, containsString,
+  getStructAttrsWithType,
+  getStructAttrs,
+  getStructTypes,
+  getStructAttrsQuery,
+  containsString
 } from './common';
 
 function sortByFirstLetter(arr: string[]): string[] {
-	return arr.sort((a, b) => {
-		const firstLetterA = a.charAt(0).toLowerCase();
-		const firstLetterB = b.charAt(0).toLowerCase();
+  return arr.sort((a, b) => {
+    const firstLetterA = a.charAt(0).toLowerCase();
+    const firstLetterB = b.charAt(0).toLowerCase();
 
-		if (firstLetterA < firstLetterB) {
-			return -1;
-		}
-		if (firstLetterA > firstLetterB) {
-			return 1;
-		}
-		return 0;
-	});
+    if (firstLetterA < firstLetterB) {
+      return -1;
+    }
+    if (firstLetterA > firstLetterB) {
+      return 1;
+    }
+    return 0;
+  });
 }
 
 export 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('');
+  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('');
 }
 
 export function renderSetAttrsFunc(
-	schemaName: string,
-	fields: BaseType | Record<string, BaseType>,
+  schemaName: string,
+  fields: BaseType | Record<string, BaseType>
 ): string {
-	return Object.entries(fields)
-		.map(
-			([key, type]) =>
-				`public(package) fun set_${key}(self: &mut ${schemaName}, ${key}: ${type}) {
+  return Object.entries(fields)
+    .map(
+      ([key, type]) =>
+        `public(package) fun set_${key}(self: &mut ${schemaName}, ${key}: ${type}) {
                         self.${key} = ${key};
-                    }`,
-		)
-		.join('\n');
+                    }`
+    )
+    .join('\n');
 }
 
-export function renderSetFunc(
-	schemaName: string,
-	fields: Record<string, string>,
-): string {
-	return `public(package) fun set(self: &mut ${schemaName}, ${getStructAttrsWithType(
-		fields,
-	)}) {
+export function renderSetFunc(schemaName: string, fields: Record<string, string>): string {
+  return `public(package) fun set(self: &mut ${schemaName}, ${getStructAttrsWithType(fields)}) {
             ${Object.entries(fields)
-		.map(([fieldName]) => `self.${fieldName} = ${fieldName};`)
-		.join('\n')}
+              .map(([fieldName]) => `self.${fieldName} = ${fieldName};`)
+              .join('\n')}
             }`;
 }
 
-export function renderGetAllFunc(
-	schemaName: string,
-	fields: Record<string, string>,
-): string {
-	return `public fun get(self: &${schemaName}): ${getStructTypes(fields)} {
+export function renderGetAllFunc(schemaName: string, fields: Record<string, string>): string {
+  return `public fun get(self: &${schemaName}): ${getStructTypes(fields)} {
         (${getStructAttrsQuery(fields)})
     }`;
 }
 
 export function renderGetAttrsFunc(
-	schemaName: string,
-	fields: BaseType | Record<string, BaseType>,
+  schemaName: string,
+  fields: BaseType | Record<string, BaseType>
 ): string {
-	return Object.entries(fields)
-		.map(
-			([
-				 key,
-				 type,
-			 ]) => `public fun get_${key}(self: &${schemaName}): ${type} {
+  return Object.entries(fields)
+    .map(
+      ([key, type]) => `public fun get_${key}(self: &${schemaName}): ${type} {
                                     self.${key}
-                                }`,
-		)
-		.join('\n');
+                                }`
+    )
+    .join('\n');
 }
 
 function convertToSnakeCase(input: string): string {
-	return input
-		.replace(/([A-Z])/g, '_$1')
-		.toLowerCase()
-		.replace(/^_/, '');
+  return input
+    .replace(/([A-Z])/g, '_$1')
+    .toLowerCase()
+    .replace(/^_/, '');
 }
 
 export async function generateSchemaData(
-	projectName: string,
-	data: Record<string, SchemaData>,
-	path: string,
+  projectName: string,
+  data: Record<string, SchemaData>,
+  path: string
 ) {
-	console.log('\n📦 Starting Schema Data Generation...');
-	for (const key of Object.keys(data)) {
-				const name = key;
-				const fields = data[key];
-				console.log(
-					`     └─ Generating ${name} ${
-						Array.isArray(fields) ? '(enum)' : '(struct)'
-					}`,
-				);
-				let code = '';
+  console.log('\n📦 Starting Schema Data Generation...');
+  for (const key of Object.keys(data)) {
+    const name = key;
+    const fields = data[key];
+    console.log(
+      `     └─ ${name} ${Array.isArray(fields) ? '(enum)' : '(struct)'}: ${JSON.stringify(fields)}`
+    );
+    let code = '';
 
-				const enumNames = Object.keys(data)
-					.filter(item => Array.isArray(data[item]))
-					.map(item => item);
+    const enumNames = Object.keys(data)
+      .filter((item) => Array.isArray(data[item]))
+      .map((item) => item);
 
-			console.log(enumNames)
-
-				if (Array.isArray(fields)) {
-					const sortByFirstLetterFields = sortByFirstLetter(fields);
-					code = `module ${projectName}::${projectName}_${convertToSnakeCase(
-						name,
-					)} {
+    if (Array.isArray(fields)) {
+      const sortByFirstLetterFields = sortByFirstLetter(fields);
+      code = `module ${projectName}::${projectName}_${convertToSnakeCase(name)} {
                         public enum ${name} has copy, drop , store {
                                 ${sortByFirstLetterFields}
                         }
                         
                         ${sortByFirstLetterFields
-						.map((field: string) => {
-							return `public fun new_${convertToSnakeCase(
-								field,
-							)}(): ${name} {
+                          .map((field: string) => {
+                            return `public fun new_${convertToSnakeCase(field)}(): ${name} {
                                 ${name}::${field}
                             }`;
-						})
-						.join('')}`;
-				} else {
-					code = `module ${projectName}::${projectName}_${convertToSnakeCase(
-						name,
-					)} {
+                          })
+                          .join('')}`;
+    } else {
+      code = `module ${projectName}::${projectName}_${convertToSnakeCase(name)} {
                             use std::ascii::String;
     
-						${
-						Object.keys(data)
-							.map(name => {
-								if (containsString(fields, name)) {
-									return `use ${projectName}::${projectName}_${convertToSnakeCase(name)}::${name};`;
-								}
-								return undefined;
-							})
-							.filter(Boolean)
-							.join('\n')
-					}
+						${Object.keys(data)
+              .map((name) => {
+                if (containsString(fields, name)) {
+                  return `use ${projectName}::${projectName}_${convertToSnakeCase(name)}::${name};`;
+                }
+                return undefined;
+              })
+              .filter(Boolean)
+              .join('\n')}
 
                            public struct ${name} has copy, drop , store {
                                 ${getStructAttrsWithType(fields)}
                            }
                         
-                           public fun new(${getStructAttrsWithType(
-						fields,
-					)}): ${name} {
+                           public fun new(${getStructAttrsWithType(fields)}): ${name} {
                                ${name} {
                                    ${getStructAttrs(fields)}
                                }
@@ -167,53 +143,40 @@ export async function generateSchemaData(
                            ${renderSetAttrsFunc(name, fields)}
                            ${renderSetFunc(name, fields)}
                         }`;
-				}
+    }
 
-				await formatAndWriteMove(
-					code,
-					`${path}/contracts/${projectName}/sources/codegen/data/${convertToSnakeCase(
-						name,
-					)}.move`,
-					'formatAndWriteMove',
-				);
-			}
-	console.log('✅ Schema Data Generation Complete\n');
+    await formatAndWriteMove(
+      code,
+      `${path}/contracts/${projectName}/sources/codegen/data/${convertToSnakeCase(name)}.move`,
+      'formatAndWriteMove'
+    );
+  }
 }
 
-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 generateSchemaStructure(
-	projectName: string,
-	data: Record<string, SchemaData> | null,
-	schemas: Record<string, SchemaType>,
-	path: string,
+  projectName: string,
+  data: Record<string, SchemaData> | null,
+  schemas: Record<string, SchemaType>,
+  path: string
 ) {
-	console.log('\n🔨 Starting Schema Structure Generation...');
-		console.log(
-			`     ├─ Output path: ${path}/contracts/${projectName}/sources/codegen/schema.move`,
-		);
-		console.log(
-			`     └─ Structure fields: ${
-				Object.values(schemas).length
-			}`,
-		);
-		const schemaMoudle = `module ${projectName}::${projectName}_schema {
+  console.log('\n🔨 Starting Schema Structure Generation...');
+  Object.entries(schemas).forEach(([key, value]) => {
+    console.log(`     └─ ${key}: ${value}`);
+  });
+  const schemaMoudle = `module ${projectName}::${projectName}_schema {
                     use std::ascii::String;
                     use std::ascii::string;
                     use sui::package::UpgradeCap;
@@ -229,8 +192,8 @@ export async function generateSchemaStructure(
                     public struct Schema has key, store { id: UID } 
                     
                      ${Object.entries(schemas)
-			.map(([key, value]) => {
-				return `public fun borrow_${key}(self: &Schema) : &${value} {
+                       .map(([key, value]) => {
+                         return `public fun borrow_${key}(self: &Schema) : &${value} {
                         storage::borrow_field(&self.id, b"${key}")
                     }
                     
@@ -238,27 +201,25 @@ export async function generateSchemaStructure(
                         storage::borrow_mut_field(&mut self.id, b"${key}")
                     }
                     `;
-			})
-			.join('')} 
+                       })
+                       .join('')} 
                      
            
                     public(package) fun create(ctx: &mut TxContext): Schema {
                       let mut id = object::new(ctx);
                       ${Object.entries(schemas)
-			.map(([key, value]) => {
-				let storage_type = '';
-				if (value.includes('StorageValue')) {
-					storage_type = `storage_value::new(b"${key}", ctx)`;
-				} else if (value.includes('StorageMap')) {
-					storage_type = `storage_map::new(b"${key}", ctx)`;
-				} else if (
-					value.includes('StorageDoubleMap')
-				) {
-					storage_type = `storage_double_map::new(b"${key}", ctx)`;
-				}
-				return `storage::add_field<${value}>(&mut id, b"${key}", ${storage_type});`;
-			})
-			.join('\n')}
+                        .map(([key, value]) => {
+                          let storage_type = '';
+                          if (value.includes('StorageValue')) {
+                            storage_type = `storage_value::new(b"${key}", ctx)`;
+                          } else if (value.includes('StorageMap')) {
+                            storage_type = `storage_map::new(b"${key}", ctx)`;
+                          } else if (value.includes('StorageDoubleMap')) {
+                            storage_type = `storage_double_map::new(b"${key}", ctx)`;
+                          }
+                          return `storage::add_field<${value}>(&mut id, b"${key}", ${storage_type});`;
+                        })
+                        .join('\n')}
                       
                       Schema { id }
                     }
@@ -276,36 +237,38 @@ export async function generateSchemaStructure(
               
                  // ======================================== View Functions ========================================
                     ${Object.entries(schemas)
-			.map(([key, value]) => {
-				// @ts-ignore
-				let all_types = value.match(/<(.+)>/)[1].split(',').map(type => type.trim());
-				let para_key: string[] = [];
-				let para_value = '';
-				let borrow_key = '';
-				if (value.includes('StorageValue')) {
-					para_key = [];
-					para_value = `${all_types[0]}`;
-					borrow_key = 'get()';
-				} else if (value.includes('StorageMap')) {
-					para_key = [`key: ${all_types[0]}`];
-					para_value = `${all_types[1]}`;
-					borrow_key = 'get(key)';
-				} else if (value.includes('StorageDoubleMap')) {
-					para_key = [`key1: ${all_types[0]}`, `key2: ${all_types[1]}`];
-					para_value = `${all_types[2]}`;
-					borrow_key = 'get(key1, key2)';
-				}
-				return `public fun get_${key}(self: &Schema, ${para_key}) : &${para_value} {
+                      .map(([key, value]) => {
+                        // @ts-ignore
+                        let all_types = value
+                          .match(/<(.+)>/)[1]
+                          .split(',')
+                          .map((type) => type.trim());
+                        let para_key: string[] = [];
+                        let para_value = '';
+                        let borrow_key = '';
+                        if (value.includes('StorageValue')) {
+                          para_key = [];
+                          para_value = `${all_types[0]}`;
+                          borrow_key = 'get()';
+                        } else if (value.includes('StorageMap')) {
+                          para_key = [`key: ${all_types[0]}`];
+                          para_value = `${all_types[1]}`;
+                          borrow_key = 'get(key)';
+                        } else if (value.includes('StorageDoubleMap')) {
+                          para_key = [`key1: ${all_types[0]}`, `key2: ${all_types[1]}`];
+                          para_value = `${all_types[2]}`;
+                          borrow_key = 'get(key1, key2)';
+                        }
+                        return `public fun get_${key}(self: &Schema, ${para_key}) : &${para_value} {
 									self.borrow_${key}().${borrow_key}
-								}`
-			}).join('\n')}
+								}`;
+                      })
+                      .join('\n')}
              // =========================================================================================================
-			}`
-		await formatAndWriteMove(
-			schemaMoudle,
-			`${path}/contracts/${projectName}/sources/codegen/schema.move`,
-			'formatAndWriteMove',
-		);
-		console.log('✅ Schema Structure Generation Complete\n');
+			}`;
+  await formatAndWriteMove(
+    schemaMoudle,
+    `${path}/contracts/${projectName}/sources/codegen/schema.move`,
+    'formatAndWriteMove'
+  );
 }
-

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

@@ -1,16 +1,13 @@
 import { DubheConfig } from '../../types';
 import { formatAndWriteMove } from '../formatAndWrite';
 
-export async function generateSchemaHub(
-	config: DubheConfig,
-	srcPrefix: string
-) {
-	console.log('\n🔑 Starting DappKey Generation...');
-	console.log(
-		`  └─ Output path: ${srcPrefix}/contracts/${config.name}/sources/codegen/schema_hub.move`
-	);
+export async function generateSchemaHub(config: DubheConfig, srcPrefix: string) {
+  console.log('\n🔑 Starting DappKey Generation...');
+  console.log(
+    `  └─ Output path: ${srcPrefix}/contracts/${config.name}/sources/codegen/schema_hub.move`
+  );
 
-	let code = `module ${config.name}::${config.name}_schema_hub {
+  let code = `module ${config.name}::${config.name}_schema_hub {
     use sui::transfer::public_share_object;
     use sui::dynamic_field as df;
 
@@ -56,10 +53,10 @@ export async function generateSchemaHub(
     }
 }
 `;
-	await formatAndWriteMove(
-		code,
-		`${srcPrefix}/contracts/${config.name}/sources/codegen/schema_hub.move`,
-		'formatAndWriteMove'
-	);
-	console.log('✅ DappKey Generation Complete\n');
+  await formatAndWriteMove(
+    code,
+    `${srcPrefix}/contracts/${config.name}/sources/codegen/schema_hub.move`,
+    'formatAndWriteMove'
+  );
+  console.log('✅ DappKey Generation Complete\n');
 }

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

@@ -5,40 +5,23 @@ import { capitalizeAndRemoveUnderscores } from './generateSchema';
 
 import { readFileSync } from 'fs';
 
-export async function generateDeployHook(
-	config: DubheConfig,
-	srcPrefix: string
-) {
-	console.log('\n📝 Starting Deploy Hook Generation...');
-	console.log(
-		`  └─ Output path: ${srcPrefix}/contracts/${config.name}/sources/scripts/deploy_hook.move`
-	);
-
-	const path = `${srcPrefix}/contracts/${config.name}/sources/scripts/deploy_hook.move`;
-	if (!existsSync(path)) {
-		const code = `module ${config.name}::${config.name}_deploy_hook {
+export async function generateDeployHook(config: DubheConfig, srcPrefix: string) {
+  const path = `${srcPrefix}/contracts/${config.name}/sources/scripts/deploy_hook.move`;
+  if (!existsSync(path)) {
+    const code = `module ${config.name}::${config.name}_deploy_hook {
 			  use ${config.name}::${config.name}_schema::Schema;
 
   public(package) fun run(_schema: &mut Schema, _ctx: &mut TxContext) {
 
   }
-}`
-		await formatAndWriteMove(
-			code,
-			path,
-			'formatAndWriteMove'
-		);
-	}
-	console.log('✅ Deploy Hook Generation Complete\n');
+}`;
+    await formatAndWriteMove(code, path, 'formatAndWriteMove');
+  }
 }
 
 export async function generateMigrate(config: DubheConfig, srcPrefix: string) {
-	if (
-		!existsSync(
-			`${srcPrefix}/contracts/${config.name}/sources/scripts/migrate.move`
-		)
-	) {
-		let code = `module ${config.name}::${config.name}_migrate {
+  if (!existsSync(`${srcPrefix}/contracts/${config.name}/sources/scripts/migrate.move`)) {
+    let code = `module ${config.name}::${config.name}_migrate {
     const ON_CHAIN_VERSION: u32 = 1;
 
     public fun on_chain_version(): u32 {
@@ -46,10 +29,10 @@ export async function generateMigrate(config: DubheConfig, srcPrefix: string) {
     }
 }
 `;
-		await formatAndWriteMove(
-			code,
-			`${srcPrefix}/contracts/${config.name}/sources/scripts/migrate.move`,
-			'formatAndWriteMove'
-		);
-	}
+    await formatAndWriteMove(
+      code,
+      `${srcPrefix}/contracts/${config.name}/sources/scripts/migrate.move`,
+      'formatAndWriteMove'
+    );
+  }
 }

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

@@ -5,18 +5,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 
 export async function generateSystem(config: DubheConfig, srcPrefix: string) {
-	console.log('\n⚙️ Starting System Generation...');
-		console.log(`  ├─ Generating systems`);
-		console.log(
-			`     └─ Output path: ${srcPrefix}/contracts/${config.name}/sources/systems`
-		);
-
-		if (
-			!existsSync(
-				`${srcPrefix}/contracts/${config.name}/sources/systems`
-			)
-		) {
-			await fs.mkdir(`${srcPrefix}/contracts/${config.name}/sources/systems`, { recursive: true })
-		}
-	console.log('✅ System Generation Complete\n');
+  if (!existsSync(`${srcPrefix}/contracts/${config.name}/sources/systems`)) {
+    await fs.mkdir(`${srcPrefix}/contracts/${config.name}/sources/systems`, { recursive: true });
+  }
 }

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

@@ -1,16 +1,11 @@
 import { DubheConfig } from '../../types';
 import { formatAndWriteMove } from '../formatAndWrite';
 
-export async function generateToml(
-	config: DubheConfig,
-	srcPrefix: string,
-) {
-	console.log('\n📄 Starting Move.toml Generation...');
-	console.log(
-		`  └─ Output path: ${srcPrefix}/contracts/${config.name}/Move.toml`
-	);
+export async function generateToml(config: DubheConfig, srcPrefix: string) {
+  console.log('\n📄 Starting Move.toml Generation...');
+  console.log(`  └─ Output path: ${srcPrefix}/contracts/${config.name}/Move.toml`);
 
-	let code = `[package]
+  let code = `[package]
 name = "${config.name}"
 version = "1.0.0"
 edition = "2024"
@@ -23,10 +18,10 @@ Dubhe = { git = "https://github.com/0xobelisk/dubhe-framework.git", rev = "dubhe
 sui = "0x2"
 ${config.name} = "0x0"
 `;
-	await formatAndWriteMove(
-		code,
-		`${srcPrefix}/contracts/${config.name}/Move.toml`,
-		'formatAndWriteMove'
-	);
-	console.log('✅ Move.toml Generation Complete\n');
+  await formatAndWriteMove(
+    code,
+    `${srcPrefix}/contracts/${config.name}/Move.toml`,
+    'formatAndWriteMove'
+  );
+  console.log('✅ Move.toml Generation Complete\n');
 }