@0xobelisk/sui-common 0.5.15 → 0.5.18

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

@@ -1,22 +1,22 @@
-import { BaseType, SchemaType, BaseValueType, MoveType } from "../../types";
-import fs from "fs";
+import { MoveType } from '../../types';
+import fs from 'fs';
 
 export function deleteFolderRecursive(path: string) {
-  if (fs.existsSync(path)) {
-    fs.readdirSync(path).forEach((file) => {
-      const curPath = `${path}/${file}`;
-      if (fs.lstatSync(curPath).isDirectory()) {
-        deleteFolderRecursive(curPath);
-      } else {
-        fs.unlinkSync(curPath);
-      }
-    });
-    fs.rmdirSync(path);
-  }
+	if (fs.existsSync(path)) {
+		fs.readdirSync(path).forEach(file => {
+			const curPath = `${path}/${file}`;
+			if (fs.lstatSync(curPath).isDirectory()) {
+				deleteFolderRecursive(curPath);
+			} else {
+				fs.unlinkSync(curPath);
+			}
+		});
+		fs.rmdirSync(path);
+	}
 }
 
 export function capitalizeFirstLetter(input: string): string {
-  return input.charAt(0).toUpperCase() + input.slice(1);
+	return input.charAt(0).toUpperCase() + input.slice(1);
 }
 
 /**
@@ -26,14 +26,16 @@ export function capitalizeFirstLetter(input: string): string {
  * @return [ name, age, birth_time ]
  */
 export function getStructAttrs(
-  values: Record<string, string> | string,
+	values: Record<string, string> | string
 ): string {
-  return Object.entries(values).map(([key, _]) => `${key}`).join(",");
+	return Object.entries(values)
+		.map(([key, _]) => `${key}`)
+		.join(',');
 }
 
 function isAddress(str: string): boolean {
-  const regex = /^0x[a-fA-F0-9]+$/;
-  return regex.test(str);
+	const regex = /^0x[a-fA-F0-9]+$/;
+	return regex.test(str);
 }
 
 /**
@@ -43,11 +45,9 @@ function isAddress(str: string): boolean {
  */
 // export function getStructTypes(values: SchemaType): string {
 export function getStructTypes(
-  values: MoveType | Record<string, MoveType>
+	values: Record<string, string>
 ): string {
-  return typeof values === "string"
-    ? values
-    : `(${Object.entries(values).map(([_, type]) => `${type}`)})`;
+	return `(${Object.entries(values).map(([_, type]) => `${type}`)})`;
 }
 
 /**
@@ -56,23 +56,17 @@ export function getStructTypes(
  * @return Attributes and types of the struct. [ name: string, age: u64 ]
  */
 export function getStructAttrsWithType(
-  values: Record<string, string>
+	values: Record<string, string>
 ): string[] {
-  return Object.entries(values).map(([key, type]) => `${key}: ${type}`);
+	return Object.entries(values).map(([key, type]) => `${key}: ${type}`);
 }
 
 /**
  * @param values
- * @param prefixArgs
  * @return [ data.name, data.age ]
  */
 export function getStructAttrsQuery(
-  values: MoveType | Record<string, MoveType>,
-  prefixArgs: string
+	values: Record<string, string>,
 ): string[] {
-  return typeof values === "string"
-    ? [`${prefixArgs}self.value`]
-    : Object.entries(values).map(
-        ([key, _]) => `${prefixArgs}self.${key}`
-      );
-}
+	return Object.entries(values).map(([key, _]) => `self.${key}`);
+}

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

@@ -1,19 +1,28 @@
-import { ObeliskConfig } from "../../types";
-import { formatAndWriteMove } from "../formatAndWrite";
+import { DubheConfig } from '../../types';
+import { formatAndWriteMove } from '../formatAndWrite';
 
-export async function generateDappKey(config: ObeliskConfig, srcPrefix: string) {
-  let code = `module ${config.name}::dapp_key {
-  /// Authorization token for the app.
-    public struct DappKey has drop {}
+export async function generateDappKey(
+	config: DubheConfig,
+	srcPrefix: string
+) {
+	console.log('\n🔑 Starting DappKey Generation...');
+	console.log(
+		`  └─ Output path: ${srcPrefix}/contracts/${config.name}/sources/codegen/dapp_key.move`
+	);
 
-    public(package) fun new(): DappKey {
-        DappKey {  }
-    }
+	let code = `module ${config.name}::dapp_key {
+\t/// Authorization token for the app.
+\tpublic struct DappKey has drop {}
+
+\tpublic(package) fun new(): DappKey {
+\t\tDappKey {  }
+\t}
 }
 `;
-  await formatAndWriteMove(
-    code,
-    `${srcPrefix}/contracts/${config.name}/sources/codegen/dapp_key.move`,
-    "formatAndWriteMove"
-  );
+	await formatAndWriteMove(
+		code,
+		`${srcPrefix}/contracts/${config.name}/sources/codegen/dapp_key.move`,
+		'formatAndWriteMove'
+	);
+	console.log('✅ DappKey Generation Complete\n');
 }

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

@@ -1,109 +1,142 @@
+import { BaseType, SchemaType } from '../../types';
+import { formatAndWriteMove } from '../formatAndWrite';
 import {
-    BaseType, SchemaType,
-} from "../../types";
-import { formatAndWriteMove } from "../formatAndWrite";
-import {
-  getStructAttrsWithType,
-  getStructAttrs,
-    getStructTypes, getStructAttrsQuery,
-} from "./common";
+	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('');
+	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>
+	schemaName: string,
+	fields: Record<string, string>
 ): string {
-  return `public(package) fun set(self: &mut ${schemaName}, ${getStructAttrsWithType(fields)}) {
+	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: BaseType | Record<string, BaseType>
+	schemaName: string,
+	fields: Record<string, string>
 ): string {
-  return `public fun get(self: &${schemaName}): ${getStructTypes(fields)} {
-        (${getStructAttrsQuery(fields, "")})
+	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, schemas: Record<string, SchemaType>, path: string) {
-    for (const schemaName in schemas) {
-        const schema = schemas[schemaName];
-        if (schema.data) {
-            for (const item of schema.data) {
-                let code = "";
+export async function generateSchemaData(
+	projectName: string,
+	schemas: Record<string, SchemaType>,
+	path: string
+) {
+	console.log('\n📦 Starting Schema Data Generation...');
+	for (const schemaName in schemas) {
+		const schema = schemas[schemaName];
+		if (schema.data) {
+			console.log(`  ├─ Processing schema: ${schemaName}`);
+			for (const item of schema.data) {
+				console.log(
+					`     └─ Generating ${item.name} ${
+						Array.isArray(item.fields) ? '(enum)' : '(struct)'
+					}`
+				);
+				let code = '';
 
-                const enumNames = schema.data
-                    .filter(item => Array.isArray(item.fields))
-                    .map(item => item.name);
+				const enumNames = schema.data
+					.filter(item => Array.isArray(item.fields))
+					.map(item => item.name);
 
-                if (Array.isArray(item.fields)) {
-                    code = `module ${projectName}::${schemaName}_${convertToSnakeCase(item.name)} {
+				if (Array.isArray(item.fields)) {
+					code = `module ${projectName}::${schemaName}_${convertToSnakeCase(
+						item.name
+					)} {
                         public enum ${item.name} has copy, drop , store {
                                 ${item.fields}
                         }
                         
-                        ${item.fields.map((field: string) => {
-                            return `public fun new_${convertToSnakeCase(field)}(): ${item.name} {
+                        ${item.fields
+							.map((field: string) => {
+								return `public fun new_${convertToSnakeCase(
+									field
+								)}(): ${item.name} {
                                 ${item.name}::${field}
-                            }`
-                        }).join("")
-                    }`
-                } else {
-                    code = `module ${projectName}::${schemaName}_${convertToSnakeCase(item.name)} {
+                            }`;
+							})
+							.join('')}`;
+				} else {
+					code = `module ${projectName}::${schemaName}_${convertToSnakeCase(
+						item.name
+					)} {
                             use std::ascii::String;
-                            ${enumNames.map(name => `use ${projectName}::${schemaName}_${convertToSnakeCase(name)}::${name};`).join('\n')}
+                            ${enumNames
+								.map(
+									name =>
+										`use ${projectName}::${schemaName}_${convertToSnakeCase(
+											name
+										)}::${name};`
+								)
+								.join('\n')}
 
                            public struct ${item.name} has copy, drop , store {
                                 ${getStructAttrsWithType(item.fields)}
                            }
                         
-                           public fun new(${getStructAttrsWithType(item.fields)}): ${item.name} {
+                           public fun new(${getStructAttrsWithType(
+								item.fields
+							)}): ${item.name} {
                                ${item.name} {
                                    ${getStructAttrs(item.fields)}
                                }
@@ -114,88 +147,130 @@ export async function generateSchemaData(projectName: string, schemas: Record<st
                            ${renderSetAttrsFunc(item.name, item.fields)}
                            ${renderSetFunc(item.name, item.fields)}
                         }`;
-                }
+				}
 
-                await formatAndWriteMove(
-                    code,
-                    `${path}/contracts/${projectName}/sources/codegen/schemas/${schemaName}_${convertToSnakeCase(item.name)}.move`,
-                    "formatAndWriteMove"
-                );
-            }
-        }
-    }
+				await formatAndWriteMove(
+					code,
+					`${path}/contracts/${projectName}/sources/codegen/schemas/${schemaName}_${convertToSnakeCase(
+						item.name
+					)}.move`,
+					'formatAndWriteMove'
+				);
+			}
+		}
+	}
+	console.log('✅ Schema Data Generation Complete\n');
 }
 
-function generateImport(projectName: string, schemaName: string, schema: SchemaType) {
-    if (schema.data) {
-        return schema.data.map(item => {
-            return `use ${projectName}::${schemaName}_${convertToSnakeCase(item.name)}::${item.name};`
-        }).join('\n');
-    } else {
-        return ""
-    }
+function generateImport(
+	projectName: string,
+	schemaName: string,
+	schema: SchemaType
+) {
+	if (schema.data) {
+		return schema.data
+			.map(item => {
+				return `use ${projectName}::${schemaName}_${convertToSnakeCase(
+					item.name
+				)}::${item.name};`;
+			})
+			.join('\n');
+	} else {
+		return '';
+	}
 }
 
-export async function generateSchemaStructure(projectName: string, schemas: Record<string, SchemaType>, path: string) {
-    for (const schemaName in schemas) {
-        console.log(`Schema: ${schemaName}`);
-        const schema = schemas[schemaName];
-        const schemaMoudle = `module ${projectName}::${schemaName}_schema {
+export async function generateSchemaStructure(
+	projectName: string,
+	schemas: Record<string, SchemaType>,
+	path: string
+) {
+	console.log('\n🔨 Starting Schema Structure Generation...');
+	for (const schemaName in schemas) {
+		console.log(`  ├─ Generating schema: ${schemaName}`);
+		console.log(
+			`     ├─ Output path: ${path}/contracts/${projectName}/sources/codegen/schemas/${schemaName}.move`
+		);
+		console.log(
+			`     └─ Structure fields: ${
+				Object.keys(schemas[schemaName].structure).length
+			}`
+		);
+		const schema = schemas[schemaName];
+		const schemaMoudle = `module ${projectName}::${schemaName}_schema {
                     use std::ascii::String;
                     use std::type_name;
-                    use obelisk::dapps_system;
-                    use obelisk::dapps_schema::Dapps;
-                    use obelisk::storage_value::{Self, StorageValue};
-                    use obelisk::storage_map::{Self, StorageMap};
-                    use obelisk::storage_double_map::{Self, StorageDoubleMap};
+                    use dubhe::dapps_system;
+                    use dubhe::dapps_schema::Dapps;
+                    use dubhe::storage_value::{Self, StorageValue};
+                    use dubhe::storage_map::{Self, StorageMap};
+                    use dubhe::storage_double_map::{Self, StorageDoubleMap};
                     use ${projectName}::dapp_key::DappKey;
                     ${generateImport(projectName, schemaName, schema)}
 
-                    public struct ${capitalizeAndRemoveUnderscores(schemaName)} has key, store {
+                    public struct ${capitalizeAndRemoveUnderscores(
+						schemaName
+					)} has key, store {
                         id: UID,
                         ${getStructAttrsWithType(schema.structure)}
                     } 
                     
-                     ${Object.entries(schema.structure).map(([key, value]) => {
-                        return `public fun borrow_${key}(self: &${capitalizeAndRemoveUnderscores(schemaName)}) : &${value} {
+                     ${Object.entries(schema.structure)
+							.map(([key, value]) => {
+								return `public fun borrow_${key}(self: &${capitalizeAndRemoveUnderscores(
+									schemaName
+								)}) : &${value} {
                         &self.${key}
                     }
                     
-                    public(package) fun borrow_mut_${key}(self: &mut ${capitalizeAndRemoveUnderscores(schemaName)}): &mut ${value} {
+                    public(package) fun borrow_mut_${key}(self: &mut ${capitalizeAndRemoveUnderscores(
+						schemaName
+					)}): &mut ${value} {
                         &mut self.${key}
                     }
-                    `
-                    }).join('')} 
+                    `;
+							})
+							.join('')} 
                     
-                    public fun register(dapps: &mut Dapps, ctx: &mut TxContext): ${capitalizeAndRemoveUnderscores(schemaName)} {
+                    public fun register(dapps: &mut Dapps, ctx: &mut TxContext): ${capitalizeAndRemoveUnderscores(
+						schemaName
+					)} {
                       let package_id = dapps_system::current_package_id<DappKey>();
                       assert!(dapps.borrow_metadata().contains_key(package_id), 0);
                       assert!(dapps.borrow_admin().get(package_id) == ctx.sender(), 0);
-                      let schema = type_name::get<${capitalizeAndRemoveUnderscores(schemaName)}>().into_string();
+                      let schema = type_name::get<${capitalizeAndRemoveUnderscores(
+							schemaName
+						)}>().into_string();
                       assert!(!dapps.borrow_schemas().get(package_id).contains(&schema), 0);
-                      dapps_system::add_schema<${capitalizeAndRemoveUnderscores(schemaName)}>(dapps, package_id, ctx);
+                      dapps_system::add_schema<${capitalizeAndRemoveUnderscores(
+							schemaName
+						)}>(dapps, package_id, ctx);
                       ${capitalizeAndRemoveUnderscores(schemaName)} {
                           id: object::new(ctx),
-                          ${Object.entries(schema.structure).map(([key, value]) => {
-                                let storage_type = ""
-                                if (value.includes("StorageValue")) {
-                                    storage_type = `storage_value::new()`
-                                } else if (value.includes("StorageMap")) {
-                                    storage_type = `storage_map::new()`
-                                } else if (value.includes("StorageDoubleMap")) {
-                                    storage_type = `storage_double_map::new()`
-                                }
-                                return `${key}: ${storage_type},`
-                            }).join(' ')
-                            }
+                          ${Object.entries(schema.structure)
+								.map(([key, value]) => {
+									let storage_type = '';
+									if (value.includes('StorageValue')) {
+										storage_type = `storage_value::new()`;
+									} else if (value.includes('StorageMap')) {
+										storage_type = `storage_map::new()`;
+									} else if (
+										value.includes('StorageDoubleMap')
+									) {
+										storage_type = `storage_double_map::new()`;
+									}
+									return `${key}: ${storage_type},`;
+								})
+								.join(' ')}
                         }
                     }
                
            }`;
-        await formatAndWriteMove(
-            schemaMoudle,
-            `${path}/contracts/${projectName}/sources/codegen/schemas/${schemaName}.move`,
-            "formatAndWriteMove"
-        );
-    }
-}
+		await formatAndWriteMove(
+			schemaMoudle,
+			`${path}/contracts/${projectName}/sources/codegen/schemas/${schemaName}.move`,
+			'formatAndWriteMove'
+		);
+	}
+	console.log('✅ Schema Structure Generation Complete\n');
+}