@0xobelisk/sui-common 1.2.0-pre.99 → 2.0.0

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

@@ -1,216 +0,0 @@
-import { DubheConfig } from '../../types';
-import { formatAndWriteMove } from '../formatAndWrite';
-import { existsSync } from 'fs';
-// import { capitalizeAndRemoveUnderscores } from './generateSchema'; // Unused
-
-export async function generateDefaultSchema(config: DubheConfig, srcPrefix: string) {
-  await generateDappSchemaMetadata(config, srcPrefix);
-  await generateDappSystem(config, srcPrefix);
-}
-
-async function generateDappSchemaMetadata(config: DubheConfig, srcPrefix: string) {
-  const path = `${srcPrefix}/src/${config.name}/sources/codegen/core/metadata.move`;
-  if (!existsSync(path)) {
-    let code = `module ${config.name}::${config.name}_dapp_metadata {
-  use std::ascii::String;
-
-  public struct DappMetadata has drop, copy, store {
-    name: String,
-    description: String,
-    cover_url: vector<String>,
-    website_url: String,
-    created_at: u64,
-    partners: vector<String>,
-  }
-
-  public fun new(
-    name: String,
-    description: String,
-    cover_url: vector<String>,
-    website_url: String,
-    created_at: u64,
-    partners: vector<String>,
-  ): DappMetadata {
-    DappMetadata {
-            name,
-            description,
-            cover_url,
-            website_url,
-            created_at,
-            partners,
-        }
-  }
-
-  public fun set(
-    self: &mut DappMetadata,
-    name: String,
-    description: String,
-    cover_url: vector<String>,
-    website_url: String,
-    created_at: u64,
-    partners: vector<String>,
-  ) {
-    self.name = name;
-    self.description = description;
-    self.cover_url = cover_url;
-    self.website_url = website_url;
-    self.created_at = created_at;
-    self.partners = partners;
-  }
-
-  public fun set_name(self: &mut DappMetadata, name: String) {
-    self.name = name;
-  }
-
-  public fun set_description(self: &mut DappMetadata, description: String) {
-    self.description = description;
-  }
-
-  public fun set_cover_url(self: &mut DappMetadata, cover_url: vector<String>) {
-    self.cover_url = cover_url;
-  }
-
-  public fun set_website_url(self: &mut DappMetadata, website_url: String) {
-    self.website_url = website_url;
-  }
-
-  public fun set_created_at(self: &mut DappMetadata, created_at: u64) {
-    self.created_at = created_at;
-  }
-
-  public fun set_partners(self: &mut DappMetadata, partners: vector<String>) {
-    self.partners = partners;
-  }
-
-  public fun get_name(self: &DappMetadata): String {
-    self.name
-  }
-
-  public fun get_description(self: &DappMetadata): String {
-    self.description
-  }
-
-  public fun get_cover_url(self: &DappMetadata): vector<String> {
-    self.cover_url
-  }
-
-  public fun get_website_url(self: &DappMetadata): String {
-    self.website_url
-  }
-
-  public fun get_created_at(self: &DappMetadata): u64 {
-    self.created_at
-  }
-
-  public fun get_partners(self: &DappMetadata): vector<String> {
-    self.partners
-  }
-}
-`;
-    await formatAndWriteMove(code, path, 'formatAndWriteMove');
-  }
-}
-
-async function generateDappSystem(config: DubheConfig, srcPrefix: string) {
-  const path = `${srcPrefix}/src/${config.name}/sources/codegen/core/system.move`;
-  if (!existsSync(path)) {
-    let code = `module ${config.name}::${config.name}_dapp_system {
-  use std::ascii::String;
-  use std::ascii;
-  use dubhe::type_info;
-  use sui::clock::Clock;
-  use sui::transfer::public_share_object;
-  use ${config.name}::${config.name}_schema::Schema;
-  use ${config.name}::${config.name}_dapp_metadata;
-  use ${config.name}::${config.name}_dapp_metadata::DappMetadata;
-  use dubhe::storage::add_field;
-  use dubhe::storage_value;
-  use dubhe::storage_value::StorageValue;
-
-  public entry fun set_metadata(
-    schema: &mut Schema,
-    name: String,
-    description: String,
-    cover_url: vector<String>,
-    website_url: String,
-    partners: vector<String>,
-    ctx: &TxContext,
-  ) {
-    let admin = schema.dapp__admin().try_get();
-    assert!(admin == option::some(ctx.sender()), 0);
-    let created_at = schema.dapp__metadata().get().get_created_at();
-    schema.dapp__metadata().set(
-            ${config.name}_dapp_metadata::new(
-                name,
-                description,
-                cover_url,
-                website_url,
-                created_at,
-                partners
-            )
-        );
-    }
-
-
-    public entry fun transfer_ownership(schema: &mut Schema, new_admin: address, ctx: &mut TxContext) {
-    let admin = schema.dapp__admin().try_get();
-    assert!(admin == option::some(ctx.sender()), 0);
-    schema.dapp__admin().set(new_admin);
-    }
-
-    public entry fun set_safe_mode(schema: &mut Schema, safe_mode: bool, ctx: &TxContext) {
-    let admin = schema.dapp__admin().try_get();
-    assert!(admin == option::some(ctx.sender()), 0);
-    schema.dapp__safe_mode().set(safe_mode);
-    }
-
-    public fun ensure_no_safe_mode(schema: &mut Schema) {
-    assert!(!schema.dapp__safe_mode()[], 0);
-    }
-
-    public fun ensure_has_authority(schema: &mut Schema, ctx: &TxContext) {
-    assert!(schema.dapp__admin().get() == ctx.sender(), 0);
-    }
-
-    public fun ensure_has_schema<S: key + store>(schema: &mut Schema, new_schema: &S) {
-    let schema_id = object::id_address(new_schema);
-    assert!(schema.dapp__authorised_schemas().get().contains(&schema_id), 0);
-    }
-
-    public(package) fun create(schema: &mut Schema, name: String, description: String, clock: &Clock, ctx: &mut TxContext){
-    add_field<StorageValue<address>>(schema.id(), b"dapp__admin", storage_value::new(b"dapp__admin", ctx));
-    add_field<StorageValue<address>>(schema.id(), b"dapp__package_id", storage_value::new(b"dapp__package_id", ctx));
-    add_field<StorageValue<u32>>(schema.id(), b"dapp__version", storage_value::new(b"dapp__version", ctx));
-    add_field<StorageValue<DappMetadata>>(schema.id(), b"dapp__metadata", storage_value::new(b"dapp__metadata", ctx));
-    add_field<StorageValue<bool>>(schema.id(), b"dapp__safe_mode", storage_value::new(b"dapp__safe_mode", ctx));
-    add_field<StorageValue<vector<address>>>(schema.id(), b"dapp__authorised_schemas", storage_value::new(b"dapp__authorised_schemas", ctx));
-    schema.dapp__metadata().set(
-            ${config.name}_dapp_metadata::new(
-                name,
-                description,
-                vector[],
-                ascii::string(b""),
-                clock.timestamp_ms(),
-                vector[]
-            )
-        );
-    let package_id = type_info::current_package_id<Schema>();
-    schema.dapp__package_id().set(package_id);
-    schema.dapp__admin().set(ctx.sender());
-    schema.dapp__version().set(1);
-    schema.dapp__safe_mode().set(false);
-    schema.dapp__authorised_schemas().set(vector[]);
-    }
-
-    public(package) fun add_schema<S: key + store>(schema: &mut Schema, new_schema: S) {
-    let mut schemas = schema.dapp__authorised_schemas()[];
-    schemas.push_back(object::id_address<S>(&new_schema));
-    schema.dapp__authorised_schemas().set(schemas);
-    public_share_object(new_schema);
-    }
-}
-
-`;
-    await formatAndWriteMove(code, path, 'formatAndWriteMove');
-  }
-}

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

@@ -1,99 +0,0 @@
-import { EventData, SchemaData } from '../../types';
-import { formatAndWriteMove } from '../formatAndWrite';
-import { getStructAttrsWithType, getStructAttrs } from './common';
-
-// 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(/^_/, '');
-}
-
-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
-) {
-  console.log('\n📦 Starting Schema Event Generation...');
-  for (const key of Object.keys(events)) {
-    const name = key;
-    const fields = events[key];
-    console.log(`     └─ ${name} event: ${JSON.stringify(fields)}`);
-
-    let code = `module ${projectName}::${projectName}_${name}_event {
-						use sui::event;
-						use std::ascii::String;
-						${generateImport(projectName, data)}
-
-                        public struct ${toPascalCase(name)}Event has copy, drop {
-                                ${getStructAttrsWithType(fields as Record<string, string>)}
-                        }
-
-                        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}/src/${projectName}/sources/codegen/data/${name}_event.move`,
-      'formatAndWriteMove'
-    );
-  }
-
-  let code = `module ${projectName}::${projectName}_events {
-	 	use std::ascii::{String, string};
-	 	${generateImport(projectName, data)}
-		${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}_${name}_event::new(${getStructAttrs(
-          fields as Record<string, string>
-        )}))
-			  )
-			}
-		`;
-      })
-      .join('\n')}		
-            }`;
-
-  await formatAndWriteMove(
-    code,
-    `${path}/src/${projectName}/sources/codegen/events.move`,
-    'formatAndWriteMove'
-  );
-}

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

@@ -1,287 +0,0 @@
-import { BaseType, SchemaData, SchemaType } from '../../types';
-import { formatAndWriteMove } from '../formatAndWrite';
-import {
-  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();
-
-    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('');
-}
-
-export function renderSetAttrsFunc(
-  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}) {
-                        self.${key} = ${key};
-                    }`
-    )
-    .join('\n');
-}
-
-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')}
-            }`;
-}
-
-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>
-): string {
-  return Object.entries(fields)
-    .map(
-      ([key, type]) => `public fun get_${key}(self: &${schemaName}): ${type} {
-                                    self.${key}
-                                }`
-    )
-    .join('\n');
-}
-
-function convertToSnakeCase(input: string): string {
-  return input
-    .replace(/([A-Z])/g, '_$1')
-    .toLowerCase()
-    .replace(/^_/, '');
-}
-
-export async function generateSchemaData(
-  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(
-      `     └─ ${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);
-
-    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} {
-                                ${name}::${field}
-                            }`;
-                          })
-                          .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')}
-
-                           public struct ${name} has copy, drop , store {
-                                ${getStructAttrsWithType(fields)}
-                           }
-
-                           public fun new(${getStructAttrsWithType(fields)}): ${name} {
-                               ${name} {
-                                   ${getStructAttrs(fields)}
-                               }
-                            }
-
-                           ${renderGetAllFunc(name, fields)}
-                           ${renderGetAttrsFunc(name, fields)}
-                           ${renderSetAttrsFunc(name, fields)}
-                           ${renderSetFunc(name, fields)}
-                        }`;
-    }
-
-    await formatAndWriteMove(
-      code,
-      `${path}/src/${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 '';
-  }
-}
-
-export async function generateSchemaStructure(
-  projectName: string,
-  data: Record<string, SchemaData> | null,
-  schemas: Record<string, SchemaType>,
-  path: string
-) {
-  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;
-                    use std::type_name;
-                    use dubhe::storage;
-                    use dubhe::${
-                      projectName == 'dubhe' ? 'storage_value_internal' : 'storage_value'
-                    }::{Self, StorageValue};
-                    use dubhe::${
-                      projectName == 'dubhe' ? 'storage_map_internal' : 'storage_map'
-                    }::{Self, StorageMap};
-                    use dubhe::${
-                      projectName == 'dubhe' ? 'storage_double_map_internal' : 'storage_double_map'
-                    }::{Self, StorageDoubleMap};
-                    use sui::dynamic_field as df;
-
-                    ${generateImport(projectName, data)}
-
-                    public struct Schema has key, store { id: UID }
-
-                     ${Object.entries(schemas)
-                       .map(([key, value]) => {
-                         return `public fun borrow_${key}(self: &Schema) : &${value} {
-                        storage::borrow_field(&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): Schema {
-                      let mut id = object::new(ctx);
-                      ${Object.entries(schemas)
-                        .map(([key, value]) => {
-                          let storage_type = '';
-                          if (value.includes('StorageValue')) {
-                            storage_type = `${
-                              projectName == 'dubhe' ? 'storage_value_internal' : 'storage_value'
-                            }::new(b"${key}", ctx)`;
-                          } else if (value.includes('StorageMap')) {
-                            storage_type = `${
-                              projectName == 'dubhe' ? 'storage_map_internal' : 'storage_map'
-                            }::new(b"${key}", ctx)`;
-                          } else if (value.includes('StorageDoubleMap')) {
-                            storage_type = `${
-                              projectName == 'dubhe'
-                                ? 'storage_double_map_internal'
-                                : 'storage_double_map'
-                            }::new(b"${key}", ctx)`;
-                          }
-                          return `storage::add_field<${value}>(&mut id, b"${key}", ${storage_type});`;
-                        })
-                        .join('\n')}
-
-                      Schema { id }
-                    }
-
-                    public(package) fun id(self: &mut Schema): &mut UID {
-					  &mut self.id
-					}
-
-					public(package) fun borrow_id(self: &Schema): &UID {
-					  &self.id
-					}
-
-          public fun migrate(_schema: &mut Schema, _ctx: &mut TxContext) {  }
-
-                 // ======================================== View Functions ========================================
-                    ${Object.entries(schemas)
-                      .map(([key, value]) => {
-                        // @ts-ignore
-                        let all_types = value
-                          .match(/<(.+)>/)[1]
-                          .split(',')
-                          .map((type: string) => 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')}
-             // =========================================================================================================
-			}`;
-  await formatAndWriteMove(
-    schemaMoudle,
-
-    `${path}/src/${projectName}/sources/codegen/core/schema.move`,
-    'formatAndWriteMove'
-  );
-}

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

@@ -1,60 +0,0 @@
-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}/src/${config.name}/sources/codegen/schema_hub.move`);
-
-  let code = `module ${config.name}::${config.name}_schema_hub {
-    use sui::transfer::public_share_object;
-    use sui::dynamic_field as df;
-
-    public struct SchemaHub has key, store {
-        id: UID,
-        admin: address,
-    }
-    
-    public struct SchemaTypeWapper<phantom Schema: key + store> has copy, store, drop {}
-
-    /// Authorize an schema to access protected features of the SchemaHub.
-    public(package) fun authorize_schema<Schema: key + store>(self: &mut SchemaHub) {
-        df::add(&mut self.id, SchemaTypeWapper<Schema> {}, true);
-    }
-
-    /// Deauthorize an schema by removing its authorization key.
-    public(package) fun deauthorize_schema<Schema: key + store>(self: &mut SchemaHub) {
-        df::remove<SchemaTypeWapper<Schema>, bool>(&mut self.id, SchemaTypeWapper<Schema> {});
-    }
-
-    /// Check if an schema is authorized to access protected features of
-    /// the SchemaHub.
-    public fun is_schema_authorized<Schema: key + store>(self: &SchemaHub): bool {
-        df::exists_(&self.id, SchemaTypeWapper<Schema> {})
-    }
-
-    /// Assert that an schema is authorized to access protected features of
-    /// the SchemaHub. Aborts with \`EAppNotAuthorized\` if not.
-    public fun ensure_schema_authorized<Schema: key + store>(self: &SchemaHub) {
-        assert!(self.is_schema_authorized<Schema>(), 0);
-    }
-
-    fun init(ctx: &mut TxContext) {
-        public_share_object(SchemaHub {
-            id: object::new(ctx),
-            admin: ctx.sender(),
-        });
-    }
-
-    #[test_only]
-    public fun init_schema_hub_for_testing(ctx: &mut TxContext) {
-        init(ctx);
-    }
-}
-`;
-  await formatAndWriteMove(
-    code,
-    `${srcPrefix}/src/${config.name}/sources/codegen/schema_hub.move`,
-    'formatAndWriteMove'
-  );
-  console.log('✅ DappKey Generation Complete\n');
-}

package/src/parseData/index.ts

@@ -1 +0,0 @@
-export * from './parser';