@0xobelisk/sui-common 1.0.3 → 1.0.4

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

@@ -13,7 +13,7 @@ export async function generateDefaultSchema(
 }
 
 async function generateDappSchemaMetadata(config: DubheConfig, srcPrefix: string) {
-	const path = `${srcPrefix}/contracts/${config.name}/sources/codegen/schemas/default/dapp/metadata.move`
+	const path = `${srcPrefix}/contracts/${config.name}/sources/codegen/dapp/metadata.move`
 	if (!existsSync(path)) {
 		let code = `module ${config.name}::dapp_metadata {
     use std::ascii::String;
@@ -122,107 +122,108 @@ async function generateDappSchemaMetadata(config: DubheConfig, srcPrefix: string
 
 
 async function generateDappSchema(config: DubheConfig, srcPrefix: string) {
-	const path = `${srcPrefix}/contracts/${config.name}/sources/codegen/schemas/default/dapp/schema.move`
+	const path = `${srcPrefix}/contracts/${config.name}/sources/codegen/dapp/schema.move`
 	if (!existsSync(path)) {
 		let code = `module ${config.name}::dapp_schema {
-    use ${config.name}::dapp_metadata::DappMetadata;
-    use dubhe::storage_value;
-    use dubhe::storage_value::StorageValue;
-    use dubhe::storage_migration;
-    use sui::transfer::public_share_object;
-    use dubhe::type_info;
-
-    public struct Dapp has key, store { id: UID }
-
-    public fun borrow_admin(self: &Dapp): &StorageValue<address> {
-        storage_migration::borrow_field(&self.id, b"admin")
-    }
-
-    public(package) fun borrow_mut_admin(self: &mut Dapp): &mut StorageValue<address> {
-        storage_migration::borrow_mut_field(&mut self.id, b"admin")
-    }
-
-    public fun borrow_package_id(self: &Dapp): &StorageValue<address> {
-        storage_migration::borrow_field(&self.id, b"package_id")
-    }
-
-    public(package) fun borrow_mut_package_id(self: &mut Dapp): &mut StorageValue<address> {
-        storage_migration::borrow_mut_field(&mut self.id, b"package_id")
-    }
-
-    public fun borrow_version(self: &Dapp): &StorageValue<u32> {
-        storage_migration::borrow_field(&self.id, b"version")
-    }
-
-    public(package) fun borrow_mut_version(self: &mut Dapp): &mut StorageValue<u32> {
-        storage_migration::borrow_mut_field(&mut self.id, b"version")
-    }
-
-    public fun borrow_metadata(self: &Dapp): &StorageValue<DappMetadata> {
-        storage_migration::borrow_field(&self.id, b"metadata")
-    }
-
-    public(package) fun borrow_mut_metadata(self: &mut Dapp): &mut StorageValue<DappMetadata> {
-        storage_migration::borrow_mut_field(&mut self.id, b"metadata")
-    }
-
-    public fun borrow_schemas(self: &Dapp): &StorageValue<vector<address>> {
-        storage_migration::borrow_field(&self.id, b"schemas")
-    }
-
-    public(package) fun borrow_mut_schemas(self: &mut Dapp): &mut StorageValue<vector<address>> {
-        storage_migration::borrow_mut_field(&mut self.id, b"schemas")
-    }
-
-    public fun borrow_safe_mode(self: &Dapp): &StorageValue<bool> {
-        storage_migration::borrow_field(&self.id, b"safe_mode")
-    }
-
-    public(package) fun borrow_mut_safe_mode(self: &mut Dapp): &mut StorageValue<bool> {
-        storage_migration::borrow_mut_field(&mut self.id, b"safe_mode")
-    }
-
-    public(package) fun create(ctx: &mut TxContext): Dapp {
-        let mut id = object::new(ctx);
-        storage_migration::add_field<StorageValue<address>>(&mut id, b"admin", storage_value::new());
-        storage_migration::add_field<StorageValue<address>>(&mut id, b"package_id", storage_value::new());
-        storage_migration::add_field<StorageValue<u32>>(&mut id, b"version", storage_value::new());
-        storage_migration::add_field<StorageValue<DappMetadata>>(&mut id, b"metadata", storage_value::new());
-        storage_migration::add_field<StorageValue<vector<address>>>(&mut id, b"schemas", storage_value::new());
-        storage_migration::add_field<StorageValue<bool>>(&mut id, b"safe_mode", storage_value::new());
-        Dapp { id }
-    }
-
-    public(package) fun upgrade<DappKey: drop>(dapp: &mut Dapp, ctx: &TxContext) {
-        assert!(dapp.borrow_metadata().contains(), 0);
-        assert!(dapp.borrow_admin().get() == ctx.sender(), 0);
-
-        let new_package_id = type_info::current_package_id<DappKey>();
-        dapp.borrow_mut_package_id().set(new_package_id);
-        dapp.borrow_mut_version().mutate!(|version| {
-        *version = *version + 1;
-        });
-    }
-
-    public(package) fun add_schema<Schema: key + store>(dapp: &mut Dapp, schema: Schema, ctx: &TxContext) {
-        assert!(dapp.borrow_metadata().contains(), 0);
-        assert!(dapp.borrow_admin().get() == ctx.sender(), 0);
-
-        let schema_id = object::id_address(&schema);
-        dapp.borrow_mut_schemas().borrow_mut().push_back(schema_id);
-        public_share_object(schema);
-    }
-
-    #[test_only]
-    public fun create_dapp_for_testing(ctx: &mut TxContext): Dapp {
-        create(ctx)
-    }
-
-    #[test_only]
-    public fun distroy_dapp_for_testing(dapp: Dapp) {
-       let Dapp { id } = dapp;
-        id.delete();
-    }
+  use ${config.name}::dapp_metadata::DappMetadata;
+  use dubhe::storage_value;
+  use dubhe::storage_value::StorageValue;
+  use dubhe::storage;
+  use sui::transfer::public_share_object;
+  use dubhe::type_info;
+  
+  public struct Dapp has key, store {
+    id: UID,
+  }
+
+  public fun borrow_admin(self: &Dapp): &StorageValue<address> {
+    storage::borrow_field(&self.id, b"admin")
+  }
+
+  public(package) fun admin(self: &mut Dapp): &mut StorageValue<address> {
+    storage::borrow_mut_field(&mut self.id, b"admin")
+  }
+
+  public fun borrow_package_id(self: &Dapp): &StorageValue<address> {
+    storage::borrow_field(&self.id, b"package_id")
+  }
+
+  public(package) fun package_id(self: &mut Dapp): &mut StorageValue<address> {
+    storage::borrow_mut_field(&mut self.id, b"package_id")
+  }
+
+  public fun borrow_version(self: &Dapp): &StorageValue<u32> {
+    storage::borrow_field(&self.id, b"version")
+  }
+
+  public(package) fun version(self: &mut Dapp): &mut StorageValue<u32> {
+    storage::borrow_mut_field(&mut self.id, b"version")
+  }
+
+  public fun borrow_metadata(self: &Dapp): &StorageValue<DappMetadata> {
+    storage::borrow_field(&self.id, b"metadata")
+  }
+
+  public(package) fun metadata(self: &mut Dapp): &mut StorageValue<DappMetadata> {
+    storage::borrow_mut_field(&mut self.id, b"metadata")
+  }
+
+  public fun borrow_safe_mode(self: &Dapp): &StorageValue<bool> {
+    storage::borrow_field(&self.id, b"safe_mode")
+  }
+
+  public(package) fun safe_mode(self: &mut Dapp): &mut StorageValue<bool> {
+    storage::borrow_mut_field(&mut self.id, b"safe_mode")
+  }
+  
+  public(package) fun borrow_schemas(self: &Dapp): &StorageValue<vector<address>> {
+      storage::borrow_field(&self.id, b"schemas")
+    }
+
+  public(package) fun schemas(self: &mut Dapp): &mut StorageValue<vector<address>> {
+    storage::borrow_mut_field(&mut self.id, b"schemas")
+  }
+
+
+  public(package) fun create(ctx: &mut TxContext): Dapp {
+    let mut id = object::new(ctx);
+    storage::add_field<StorageValue<address>>(&mut id, b"admin", storage_value::new(b"admin", ctx));
+    storage::add_field<StorageValue<address>>(&mut id, b"package_id", storage_value::new(b"package_id", ctx));
+    storage::add_field<StorageValue<u32>>(&mut id, b"version", storage_value::new(b"version", ctx));
+    storage::add_field<StorageValue<DappMetadata>>(&mut id, b"metadata", storage_value::new(b"metadata", ctx));
+    storage::add_field<StorageValue<bool>>(&mut id, b"safe_mode", storage_value::new(b"safe_mode", ctx));
+    storage::add_field<StorageValue<vector<address>>>(&mut id, b"schemas", storage_value::new(b"schemas", ctx));
+    Dapp { id }
+  }
+
+  public(package) fun upgrade<DappKey: drop>(dapp: &mut Dapp, ctx: &TxContext) {
+    assert!(dapp.borrow_metadata().contains(), 0);
+    assert!(dapp.borrow_admin().get() == ctx.sender(), 0);
+    let new_package_id = type_info::current_package_id<DappKey>();
+    dapp.package_id().set(new_package_id);
+    let current_version = dapp.version()[];
+    dapp.version().set(current_version + 1);
+  }
+  
+  public(package) fun add_schema<Schema: key + store>(dapp: &mut Dapp, schema: Schema) {
+    let mut schemas = dapp.schemas()[];
+    schemas.push_back(object::id_address<Schema>(&schema));
+    dapp.schemas().set(schemas);
+    public_share_object(schema);
+  }
+
+  #[test_only]
+
+  public fun create_dapp_for_testing(ctx: &mut TxContext): Dapp {
+    create(ctx)
+  }
+
+  #[test_only]
+
+  public fun distroy_dapp_for_testing(dapp: Dapp) {
+    let Dapp { id } = dapp;
+    id.delete();
+  }
 }
 `;
 		await formatAndWriteMove(
@@ -234,27 +235,26 @@ async function generateDappSchema(config: DubheConfig, srcPrefix: string) {
 }
 
 async function generateDappSystem(config: DubheConfig, srcPrefix: string) {
-	const path = `${srcPrefix}/contracts/${config.name}/sources/codegen/schemas/default/dapp/system.move`
+	const path = `${srcPrefix}/contracts/${config.name}/sources/codegen/dapp/system.move`
 	if (!existsSync(path)) {
 		let code = `module ${config.name}::dapp_system {
-    use std::ascii::String;
-    use std::ascii;
-    use dubhe::type_info;
-    use sui::clock::Clock;
-    use ${config.name}::dapp_schema;
-    use ${config.name}::dapp_metadata;
-    use ${config.name}::dapp_schema::Dapp;
-
-    public struct DappKey has drop {}
-
-    public(package) fun new(): DappKey {
-        DappKey {  }
-    }
-
-    public(package) fun create(name: String, description: String, clock: &Clock, ctx: &mut TxContext): Dapp {
-        let mut dapp = dapp_schema::create(ctx);
-        assert!(!dapp.borrow_metadata().contains(), 0);
-        dapp.borrow_mut_metadata().set(
+  use std::ascii::String;
+  use std::ascii;
+  use dubhe::type_info;
+  use sui::clock::Clock;
+  use ${config.name}::dapp_schema;
+  use ${config.name}::dapp_metadata;
+  use ${config.name}::dapp_schema::Dapp;
+  
+  public struct DappKey has drop {}
+  public(package) fun new(): DappKey {
+    DappKey {  }
+  }
+
+  public(package) fun create(name: String, description: String, clock: &Clock, ctx: &mut TxContext): Dapp {
+    let mut dapp = dapp_schema::create(ctx);
+    assert!(!dapp.borrow_metadata().contains(), 0);
+    dapp.metadata().set(
             dapp_metadata::new(
                 name,
                 description,
@@ -264,20 +264,28 @@ async function generateDappSystem(config: DubheConfig, srcPrefix: string) {
                 vector[]
             )
         );
-        let package_id = type_info::current_package_id<DappKey>();
-        dapp.borrow_mut_package_id().set(package_id);
-        dapp.borrow_mut_admin().set(ctx.sender());
-        dapp.borrow_mut_version().set(1);
-        dapp.borrow_mut_safe_mode().set(false);
-        dapp.borrow_mut_schemas().set(vector[]);
-        dapp
-    }
-
-    public entry fun set_metadata(dapp: &mut Dapp, name: String, description: String, icon_url: String, website_url: String, partners: vector<String>, ctx: &TxContext) {
-        assert!(dapp.borrow_admin().contains(), 0);
-        assert!(dapp.borrow_admin().get() == ctx.sender(), 0);
-        let created_at = dapp.borrow_mut_metadata().take().get_created_at();
-        dapp.borrow_mut_metadata().set(
+    let package_id = type_info::current_package_id<DappKey>();
+    dapp.package_id().set(package_id);
+    dapp.admin().set(ctx.sender());
+    dapp.version().set(1);
+    dapp.safe_mode().set(false);
+    dapp.schemas().set(vector[]);
+    dapp
+  }
+
+  public entry fun set_metadata(
+    dapp: &mut Dapp,
+    name: String,
+    description: String,
+    icon_url: String,
+    website_url: String,
+    partners: vector<String>,
+    ctx: &TxContext,
+  ) {
+      let admin = dapp.admin().try_get();
+      assert!(admin == option::some(ctx.sender()), 0);
+    let created_at = dapp.metadata().remove().get_created_at();
+    dapp.metadata().set(
             dapp_metadata::new(
                 name,
                 description,
@@ -287,36 +295,35 @@ async function generateDappSystem(config: DubheConfig, srcPrefix: string) {
                 partners
             )
         );
-    }
-
-    public entry fun transfer_ownership(dapp: &mut Dapp, new_admin: address, ctx: &mut TxContext) {
-        assert!(dapp.borrow_admin().contains(), 0);
-        assert!(dapp.borrow_admin().get() == ctx.sender(), 0);
-
-        dapp.borrow_mut_admin().set(new_admin);
-    }
-
-    public entry fun set_safe_mode(dapp: &mut Dapp, safe_mode: bool, ctx: &TxContext) {
-        assert!(dapp.borrow_admin().contains(), 0);
-        assert!(dapp.borrow_admin().get() == ctx.sender(), 0);
-
-        dapp.borrow_mut_safe_mode().set(safe_mode);
-    }
-
-    public fun ensure_no_safe_mode(dapp: &Dapp) {
-        assert!(!dapp.borrow_safe_mode().get(), 0);
-    }
-
-    public fun ensure_has_authority(dapp: &Dapp, ctx: &TxContext) {
-        assert!(dapp.borrow_admin().get() == ctx.sender(), 0);
-    }
-
-    public fun ensure_has_schema<Schema: key + store>(dapp: &Dapp, schema: &Schema) {
-        let schema_id = object::id_address(schema);
-        assert!(dapp.borrow_schemas().get().contains(&schema_id), 0);
-    }
+  }
+
+  public entry fun transfer_ownership(dapp: &mut Dapp, new_admin: address, ctx: &mut TxContext) {
+      let admin = dapp.admin().try_get();
+      assert!(admin == option::some(ctx.sender()), 0);
+        dapp.admin().set(new_admin);
+  }
+
+  public entry fun set_safe_mode(dapp: &mut Dapp, safe_mode: bool, ctx: &TxContext) {
+      let admin = dapp.admin().try_get();
+      assert!(admin == option::some(ctx.sender()), 0);
+    dapp.safe_mode().set(safe_mode);
+  }
+
+  public fun ensure_no_safe_mode(dapp: &Dapp) {
+    assert!(!dapp.borrow_safe_mode()[], 0);
+  }
+
+  public fun ensure_has_authority(dapp: &Dapp, ctx: &TxContext) {
+    assert!(dapp.borrow_admin().get() == ctx.sender(), 0);
+  }
+
+  public fun ensure_has_schema<Schema: key + store>(dapp: &Dapp, schema: &Schema) {
+    let schema_id = object::id_address(schema);
+    assert!(dapp.borrow_schemas().get().contains(&schema_id), 0);
+  }
 }
 
+
 `;
 		await formatAndWriteMove(
 			code,

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

@@ -7,6 +7,21 @@ import {
 	getStructAttrsQuery,
 } from './common';
 
+function sortByFirstLetter(arr: string[]): string[] {
+	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;
+	});
+}
+
 export function capitalizeAndRemoveUnderscores(input: string): string {
 	return input
 		.split('_')
@@ -100,14 +115,15 @@ export async function generateSchemaData(
 			console.log(enumNames)
 
 				if (Array.isArray(fields)) {
+					const sortByFirstLetterFields = sortByFirstLetter(fields);
 					code = `module ${projectName}::${convertToSnakeCase(
 						name,
 					)} {
                         public enum ${name} has copy, drop , store {
-                                ${fields}
+                                ${sortByFirstLetterFields}
                         }
                         
-                        ${fields
+                        ${sortByFirstLetterFields
 						.map((field: string) => {
 							return `public fun new_${convertToSnakeCase(
 								field,
@@ -185,138 +201,99 @@ export async function generateSchemaStructure(
 	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`,
+			`     ├─ Output path: ${path}/contracts/${projectName}/sources/codegen/schema.move`,
 		);
 		console.log(
 			`     └─ Structure fields: ${
-				Object.values(schemas[schemaName]).length
+				Object.values(schemas).length
 			}`,
 		);
-		const schema = schemas[schemaName];
-		const schemaMoudle = `module ${projectName}::${schemaName}_schema {
+		const schemaMoudle = `module ${projectName}::schema {
                     use std::ascii::String;
                     use std::ascii::string;
                     use sui::package::UpgradeCap;
                     use std::type_name; 
-                    use dubhe::storage_migration;
+                    use dubhe::storage;
                     use dubhe::storage_value::{Self, StorageValue};
                     use dubhe::storage_map::{Self, StorageMap};
                     use dubhe::storage_double_map::{Self, StorageDoubleMap};
                     use sui::dynamic_field as df;
-                    use sui::sui::SUI;
-                    use sui::coin::Coin;
-    				use sui::balance::Balance;
+                
                     ${generateImport(projectName, data)}
 
-                    public struct ${capitalizeAndRemoveUnderscores(
-			schemaName,
-		)} has key, store {
-                        id: UID
-											} 
+                    public struct Schema has key, store { id: UID } 
                     
-                     ${Object.entries(schema)
+                     ${Object.entries(schemas)
 			.map(([key, value]) => {
-				return `public fun borrow_${key}(self: &${capitalizeAndRemoveUnderscores(
-					schemaName,
-				)}) : &${value} {
-                        storage_migration::borrow_field(&self.id, b"${key}")
+				return `public fun borrow_${key}(self: &Schema) : &${value} {
+                        storage::borrow_field(&self.id, b"${key}")
                     }
                     
-                    public(package) fun ${key}(self: &mut ${capitalizeAndRemoveUnderscores(
-					schemaName,
-				)}): &mut ${value} {
-                        storage_migration::borrow_mut_field(&mut self.id, b"${key}")
+                    public(package) fun ${key}(self: &mut Schema): &mut ${value} {
+                        storage::borrow_mut_field(&mut self.id, b"${key}")
                     }
                     `;
 			})
 			.join('')} 
                      
            
-                    public(package) fun create(ctx: &mut TxContext): ${capitalizeAndRemoveUnderscores(
-			schemaName,
-		)} {
+                    public(package) fun create(ctx: &mut TxContext): Schema {
                       let mut id = object::new(ctx);
-                      ${Object.entries(schema)
+                      ${Object.entries(schemas)
 			.map(([key, value]) => {
 				let storage_type = '';
 				if (value.includes('StorageValue')) {
-					storage_type = `storage_value::new()`;
+					storage_type = `storage_value::new(b"${key}", ctx)`;
 				} else if (value.includes('StorageMap')) {
-					storage_type = `storage_map::new()`;
+					storage_type = `storage_map::new(b"${key}", ctx)`;
 				} else if (
 					value.includes('StorageDoubleMap')
 				) {
-					storage_type = `storage_double_map::new()`;
+					storage_type = `storage_double_map::new(b"${key}", ctx)`;
 				}
-				return `storage_migration::add_field<${value}>(&mut id, b"${key}", ${storage_type});`;
+				return `storage::add_field<${value}>(&mut id, b"${key}", ${storage_type});`;
 			})
-			.join('')}
+			.join('\n')}
                       
-                      ${capitalizeAndRemoveUnderscores(schemaName)} { id }
+                      Schema { id }
                     }
                     
-                    public fun migrate(_${schemaName}: &mut ${capitalizeAndRemoveUnderscores(schemaName)}, _cap: &UpgradeCap) {  }
+                    public fun migrate(_schema: &mut Schema, _cap: &UpgradeCap, _ctx: &mut TxContext) {  }
 
-                    
               
                  // ======================================== View Functions ========================================
-                    ${Object.entries(schema)
+                    ${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 = '';
-				let extra_code = '';
 				if (value.includes('StorageValue')) {
 					para_key = [];
 					para_value = `${all_types[0]}`;
-					borrow_key = 'borrow()';
+					borrow_key = 'get()';
 				} else if (value.includes('StorageMap')) {
 					para_key = [`key: ${all_types[0]}`];
 					para_value = `${all_types[1]}`;
-					borrow_key = 'borrow(key)';
-					if (!value.includes('Balance') && !value.includes('Coin')) {
-						extra_code = `public fun get_${key}_keys(self: &${capitalizeAndRemoveUnderscores(schemaName)}) : vector<${all_types[0]}> {
-									self.borrow_${key}().keys()
-								}
-							
-							public fun get_${key}_values(self: &${capitalizeAndRemoveUnderscores(schemaName)}) : vector<${all_types[1]}> {
-									self.borrow_${key}().values()
-								}`;
-					}
+					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 = 'borrow(key1, key2)';
-					if (!value.includes('Balance') && !value.includes('Coin')) {
-						extra_code = `public fun get_${key}_keys(self: &${capitalizeAndRemoveUnderscores(schemaName)}) : (vector<${all_types[0]}>, vector<${all_types[1]}>) {
-									self.borrow_${key}().keys()
-								}
-							
-							public fun get_${key}_values(self: &${capitalizeAndRemoveUnderscores(schemaName)}) : vector<${all_types[2]}> {
-									self.borrow_${key}().values()
-								}`;
-					}
+					borrow_key = 'get(key1, key2)';
 				}
-				return `public fun get_${key}(self: &${capitalizeAndRemoveUnderscores(schemaName)}, ${para_key}) : &${para_value} {
+				return `public fun get_${key}(self: &Schema, ${para_key}) : &${para_value} {
 									self.borrow_${key}().${borrow_key}
-								}
-								` + extra_code;
-			})
-			.join('')} 
+								}`
+			}).join('\n')}
              // =========================================================================================================
-                    
-               
-           }`;
+			}`
 		await formatAndWriteMove(
 			schemaMoudle,
-			`${path}/contracts/${projectName}/sources/codegen/schemas/${schemaName}.move`,
+			`${path}/contracts/${projectName}/sources/codegen/schema.move`,
 			'formatAndWriteMove',
 		);
-	}
-	console.log('✅ Schema Structure Generation Complete\n');
+		console.log('✅ Schema Structure Generation Complete\n');
 }
+

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

@@ -35,24 +35,17 @@ export async function generateDeployHook(
 			use std::ascii::string;
 			use sui::clock::Clock;
 			use ${config.name}::dapp_system;
-		  ${importSchemas}
 		  public entry fun run(clock: &Clock, ctx: &mut TxContext) {
 		  // Create a dapp.
     	  let mut dapp = dapp_system::create(string(b"${config.name}"),string(b"${config.description}"), clock , ctx);
     
 		 // Create schemas
-			${Object.keys(config.schemas).map(schemaName => {
-				return `let mut ${schemaName} = ${config.name}::${schemaName}_schema::create(ctx);`;
-			}).join('\n')}
+		let mut schema = ${config.name}::schema::create(ctx);
 			// Logic that needs to be automated once the contract is deployed
 			{
 			};
 			// Authorize schemas and public share objects
-			${Object.keys(config.schemas).map(schemaName => {
-					return `
-					 dapp.add_schema<${capitalizeAndRemoveUnderscores(schemaName)}>(${schemaName}, ctx);
-					 `;
-				}).join('\n')}
+			 dapp.add_schema(schema);
 			 sui::transfer::public_share_object(dapp);
 		  }
 }` } else {
@@ -61,15 +54,12 @@ export async function generateDeployHook(
 			use std::ascii::string;
 			use sui::clock::Clock;
 			use ${config.name}::dapp_system;
-		  ${importSchemas}
 		  public entry fun run(clock: &Clock, ctx: &mut TxContext) {
 		  // Create a dapp.
     	  let mut dapp = dapp_system::create(string(b"${config.name}"),string(b"${config.description}"), clock , ctx);
     
 		 // Create schemas
-			${Object.keys(config.schemas).map(schemaName => {
-			return `let mut ${schemaName} = ${config.name}::${schemaName}_schema::create(ctx);`;
-		}).join('\n')}
+			let mut schema = ${config.name}::schema::create(ctx);
 			// Logic that needs to be automated once the contract is deployed
 			
 			{
@@ -77,11 +67,7 @@ export async function generateDeployHook(
 			};
 			
 			// Authorize schemas and public share objects
-			${Object.keys(config.schemas).map(schemaName => {
-			return `
-					 dapp.add_schema<${capitalizeAndRemoveUnderscores(schemaName)}>(${schemaName}, ctx);
-					 `;
-		}).join('\n')}
+			 dapp.add_schema(schema);
 			 sui::transfer::public_share_object(dapp);
 		  }
 }`