@r2wa-org/eden 0.0.79 → 0.0.80

package/dist/src/wallet-type/admin/service.d.ts

@@ -0,0 +1,109 @@
+import { InternalWalletTypeService } from "../internal/service";
+import type { WalletTypeAdminListQueryType, WalletTypeCreateInputType, WalletTypeUpdateInputType } from "./dto.schemas";
+export declare abstract class AdminWalletTypeService extends InternalWalletTypeService {
+    static listWalletTypes(options?: WalletTypeAdminListQueryType): Promise<{
+        items: {
+            allowedLedgerAccountTypes: {
+                id: string;
+                key: string;
+                name: string;
+                description: string | null;
+                isActive: boolean;
+            }[];
+            id: string;
+            key: string;
+            name: string;
+            isSingleton: boolean;
+            isActive: boolean;
+            sortOrder: number;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+    }>;
+    static getWalletTypeDetailByKey(key: string): Promise<{
+        allowedLedgerAccountTypes: {
+            id: string;
+            key: string;
+            name: string;
+            description: string | null;
+            isActive: boolean;
+        }[];
+        id: string;
+        key: string;
+        name: string;
+        isSingleton: boolean;
+        isActive: boolean;
+        sortOrder: number;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    static createWalletType(input: WalletTypeCreateInputType): Promise<{
+        allowedLedgerAccountTypes: {
+            id: string;
+            key: string;
+            name: string;
+            description: string | null;
+            isActive: boolean;
+        }[];
+        id: string;
+        key: string;
+        name: string;
+        isSingleton: boolean;
+        isActive: boolean;
+        sortOrder: number;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    static updateWalletType(key: string, input: WalletTypeUpdateInputType): Promise<{
+        allowedLedgerAccountTypes: {
+            id: string;
+            key: string;
+            name: string;
+            description: string | null;
+            isActive: boolean;
+        }[];
+        id: string;
+        key: string;
+        name: string;
+        isSingleton: boolean;
+        isActive: boolean;
+        sortOrder: number;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    static enableWalletType(key: string): Promise<{
+        allowedLedgerAccountTypes: {
+            id: string;
+            key: string;
+            name: string;
+            description: string | null;
+            isActive: boolean;
+        }[];
+        id: string;
+        key: string;
+        name: string;
+        isSingleton: boolean;
+        isActive: boolean;
+        sortOrder: number;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    static disableWalletType(key: string): Promise<{
+        allowedLedgerAccountTypes: {
+            id: string;
+            key: string;
+            name: string;
+            description: string | null;
+            isActive: boolean;
+        }[];
+        id: string;
+        key: string;
+        name: string;
+        isSingleton: boolean;
+        isActive: boolean;
+        sortOrder: number;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+}

package/dist/src/wallet-type/db.schemas.d.ts

@@ -0,0 +1,278 @@
+export declare const walletTypeSelectSchema: import("drizzle-typebox").BuildSchema<"select", {
+    createdAt: import("drizzle-orm/pg-core").PgColumn<{
+        name: "created_at";
+        tableName: "wallet_type";
+        dataType: "date";
+        columnType: "PgTimestamp";
+        data: Date;
+        driverParam: string;
+        notNull: true;
+        hasDefault: true;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+        name: "updated_at";
+        tableName: "wallet_type";
+        dataType: "date";
+        columnType: "PgTimestamp";
+        data: Date;
+        driverParam: string;
+        notNull: true;
+        hasDefault: true;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    id: import("drizzle-orm/pg-core").PgColumn<{
+        name: "id";
+        tableName: "wallet_type";
+        dataType: "string";
+        columnType: "PgUUID";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: true;
+        isPrimaryKey: true;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    key: import("drizzle-orm/pg-core").PgColumn<{
+        name: "key";
+        tableName: "wallet_type";
+        dataType: "string";
+        columnType: "PgText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    name: import("drizzle-orm/pg-core").PgColumn<{
+        name: "name";
+        tableName: "wallet_type";
+        dataType: "string";
+        columnType: "PgText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    isSingleton: import("drizzle-orm/pg-core").PgColumn<{
+        name: "is_singleton";
+        tableName: "wallet_type";
+        dataType: "boolean";
+        columnType: "PgBoolean";
+        data: boolean;
+        driverParam: boolean;
+        notNull: true;
+        hasDefault: true;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    isActive: import("drizzle-orm/pg-core").PgColumn<{
+        name: "is_active";
+        tableName: "wallet_type";
+        dataType: "boolean";
+        columnType: "PgBoolean";
+        data: boolean;
+        driverParam: boolean;
+        notNull: true;
+        hasDefault: true;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    sortOrder: import("drizzle-orm/pg-core").PgColumn<{
+        name: "sort_order";
+        tableName: "wallet_type";
+        dataType: "number";
+        columnType: "PgInteger";
+        data: number;
+        driverParam: string | number;
+        notNull: true;
+        hasDefault: true;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+}, undefined>;
+export type WalletTypeSelectSchemaType = typeof walletTypeSelectSchema.static;
+export declare const walletTypeInsertSchema: import("drizzle-typebox").BuildSchema<"insert", {
+    createdAt: import("drizzle-orm/pg-core").PgColumn<{
+        name: "created_at";
+        tableName: "wallet_type";
+        dataType: "date";
+        columnType: "PgTimestamp";
+        data: Date;
+        driverParam: string;
+        notNull: true;
+        hasDefault: true;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+        name: "updated_at";
+        tableName: "wallet_type";
+        dataType: "date";
+        columnType: "PgTimestamp";
+        data: Date;
+        driverParam: string;
+        notNull: true;
+        hasDefault: true;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    id: import("drizzle-orm/pg-core").PgColumn<{
+        name: "id";
+        tableName: "wallet_type";
+        dataType: "string";
+        columnType: "PgUUID";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: true;
+        isPrimaryKey: true;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    key: import("drizzle-orm/pg-core").PgColumn<{
+        name: "key";
+        tableName: "wallet_type";
+        dataType: "string";
+        columnType: "PgText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    name: import("drizzle-orm/pg-core").PgColumn<{
+        name: "name";
+        tableName: "wallet_type";
+        dataType: "string";
+        columnType: "PgText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    isSingleton: import("drizzle-orm/pg-core").PgColumn<{
+        name: "is_singleton";
+        tableName: "wallet_type";
+        dataType: "boolean";
+        columnType: "PgBoolean";
+        data: boolean;
+        driverParam: boolean;
+        notNull: true;
+        hasDefault: true;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    isActive: import("drizzle-orm/pg-core").PgColumn<{
+        name: "is_active";
+        tableName: "wallet_type";
+        dataType: "boolean";
+        columnType: "PgBoolean";
+        data: boolean;
+        driverParam: boolean;
+        notNull: true;
+        hasDefault: true;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+    sortOrder: import("drizzle-orm/pg-core").PgColumn<{
+        name: "sort_order";
+        tableName: "wallet_type";
+        dataType: "number";
+        columnType: "PgInteger";
+        data: number;
+        driverParam: string | number;
+        notNull: true;
+        hasDefault: true;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+    }, {}, {}>;
+}, undefined>;
+export type WalletTypeInsertSchemaType = typeof walletTypeInsertSchema.static;

package/dist/src/wallet-type/errors/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./locales/zh";
+export declare const WalletTypeErrorCodes: {
+    readonly WALLET_TYPE_CREATE_FAILED: "WALLET_TYPE_CREATE_FAILED";
+    readonly WALLET_TYPE_NOT_FOUND: "WALLET_TYPE_NOT_FOUND";
+    readonly WALLET_TYPE_KEY_ALREADY_EXISTS: "WALLET_TYPE_KEY_ALREADY_EXISTS";
+    readonly WALLET_TYPE_ALLOWED_LEDGER_ACCOUNT_TYPE_INVALID: "WALLET_TYPE_ALLOWED_LEDGER_ACCOUNT_TYPE_INVALID";
+    readonly WALLET_TYPE_ALLOWED_LEDGER_ACCOUNT_TYPE_INACTIVE: "WALLET_TYPE_ALLOWED_LEDGER_ACCOUNT_TYPE_INACTIVE";
+    readonly WALLET_TYPE_SINGLETON_CONFLICT: "WALLET_TYPE_SINGLETON_CONFLICT";
+};
+type WalletTypeErrorCodesType = typeof WalletTypeErrorCodes;
+export type WalletTypeErrorCode = keyof WalletTypeErrorCodesType;
+declare module "../../error/errorcode" {
+    interface ErrorCodeRegistry extends WalletTypeErrorCodesType {
+    }
+}

package/dist/src/wallet-type/errors/locales/zh.d.ts

@@ -0,0 +1,14 @@
+export declare const zh: {
+    WALLET_TYPE_CREATE_FAILED: string;
+    WALLET_TYPE_NOT_FOUND: string;
+    WALLET_TYPE_KEY_ALREADY_EXISTS: string;
+    WALLET_TYPE_ALLOWED_LEDGER_ACCOUNT_TYPE_INVALID: string;
+    WALLET_TYPE_ALLOWED_LEDGER_ACCOUNT_TYPE_INACTIVE: string;
+    WALLET_TYPE_SINGLETON_CONFLICT: string;
+};
+type ZHType = typeof zh;
+declare module "../../../error/messages" {
+    interface ErrorMessageRegistry extends ZHType {
+    }
+}
+export {};

package/dist/src/wallet-type/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./admin/dto.schemas";
+export * from "./admin/service";
+export * from "./db.schemas";
+export * from "./internal/service";
+export * from "./permissions";
+export * from "./schema";
+export * from "./seed";
+export * from "./user/dto.schemas";
+export { walletTypeRouter } from "./user/router";
+export * from "./user/service";

package/dist/src/wallet-type/internal/service.d.ts

@@ -0,0 +1,256 @@
+import type { TransactionTx } from "../../db/transaction";
+import type { WalletTypeAdminListQueryType, WalletTypeCreateInputType, WalletTypeUpdateInputType } from "../admin/dto.schemas";
+export interface WalletTypeListQueryOptions extends WalletTypeAdminListQueryType {
+}
+declare abstract class BaseWalletTypeService {
+    protected static isUniqueViolationError(error: unknown): boolean;
+    protected static buildWhere(options?: WalletTypeListQueryOptions, defaultIsActive?: boolean): import("drizzle-orm").SQL<unknown> | undefined;
+    protected static serializeWalletType(item: {
+        id: string;
+        key: string;
+        name: string;
+        isSingleton: boolean;
+        isActive: boolean;
+        sortOrder: number;
+        createdAt: Date;
+        updatedAt: Date;
+        allowedLedgerAccountTypes: Array<{
+            ledgerAccountType: {
+                id: string;
+                key: string;
+                name: string;
+                description: string | null;
+                isActive: boolean;
+            };
+        }>;
+    }): {
+        allowedLedgerAccountTypes: {
+            id: string;
+            key: string;
+            name: string;
+            description: string | null;
+            isActive: boolean;
+        }[];
+        id: string;
+        key: string;
+        name: string;
+        isSingleton: boolean;
+        isActive: boolean;
+        sortOrder: number;
+        createdAt: Date;
+        updatedAt: Date;
+    };
+    protected static validateAllowedLedgerAccountTypeIds(tx: TransactionTx, ids: string[]): Promise<string[]>;
+    protected static ensureSingletonWalletConflictFree(tx: TransactionTx, walletTypeId: string): Promise<void>;
+}
+export declare abstract class InternalWalletTypeService extends BaseWalletTypeService {
+    static getWalletTypeByKeyInternal(key: string): Promise<{
+        allowedLedgerAccountTypes: {
+            id: string;
+            key: string;
+            name: string;
+            description: string | null;
+            isActive: boolean;
+        }[];
+        id: string;
+        key: string;
+        name: string;
+        isSingleton: boolean;
+        isActive: boolean;
+        sortOrder: number;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    static getWalletTypeByKey(tx: TransactionTx, key: string): Promise<{
+        id: string;
+        name: string;
+        createdAt: Date;
+        updatedAt: Date;
+        key: string;
+        isActive: boolean;
+        sortOrder: number;
+        isSingleton: boolean;
+        allowedLedgerAccountTypes: {
+            ledgerAccountTypeId: string;
+            walletTypeId: string;
+            ledgerAccountType: {
+                id: string;
+                name: string;
+                createdAt: Date;
+                updatedAt: Date;
+                description: string | null;
+                key: string;
+                isActive: boolean;
+                allowDeposit: boolean;
+                allowWithdraw: boolean;
+                minWithdrawAmount: string;
+                maxWithdrawAmount: string;
+                allowTransfer: boolean;
+                minTransferAmount: string;
+                maxTransferAmount: string;
+                allowInternalTransfer: boolean;
+                allowInternalReceiveTransfer: boolean;
+                minInternalTransferAmount: string;
+                maxInternalTransferAmount: string;
+                internalTransferRatio: string;
+                allowTransaction: boolean;
+                hasExpiry: boolean;
+                expiryDays: number | null;
+                sortOrder: number;
+            };
+        }[];
+    } | undefined>;
+    static listActiveSingletonWalletTypes(tx: TransactionTx): Promise<{
+        id: string;
+        name: string;
+        createdAt: Date;
+        updatedAt: Date;
+        key: string;
+        isActive: boolean;
+        sortOrder: number;
+        isSingleton: boolean;
+        allowedLedgerAccountTypes: {
+            ledgerAccountTypeId: string;
+            walletTypeId: string;
+            ledgerAccountType: {
+                id: string;
+                name: string;
+                createdAt: Date;
+                updatedAt: Date;
+                description: string | null;
+                key: string;
+                isActive: boolean;
+                allowDeposit: boolean;
+                allowWithdraw: boolean;
+                minWithdrawAmount: string;
+                maxWithdrawAmount: string;
+                allowTransfer: boolean;
+                minTransferAmount: string;
+                maxTransferAmount: string;
+                allowInternalTransfer: boolean;
+                allowInternalReceiveTransfer: boolean;
+                minInternalTransferAmount: string;
+                maxInternalTransferAmount: string;
+                internalTransferRatio: string;
+                allowTransaction: boolean;
+                hasExpiry: boolean;
+                expiryDays: number | null;
+                sortOrder: number;
+            };
+        }[];
+    }[]>;
+    static resolveWalletTypeForAccount(tx: TransactionTx, params: {
+        assetId: string;
+        accountTypeKey: string;
+    }): Promise<{
+        id: string;
+        name: string;
+        createdAt: Date;
+        updatedAt: Date;
+        key: string;
+        isActive: boolean;
+        sortOrder: number;
+        isSingleton: boolean;
+        allowedLedgerAccountTypes: {
+            ledgerAccountTypeId: string;
+            walletTypeId: string;
+            ledgerAccountType: {
+                id: string;
+                name: string;
+                createdAt: Date;
+                updatedAt: Date;
+                description: string | null;
+                key: string;
+                isActive: boolean;
+                allowDeposit: boolean;
+                allowWithdraw: boolean;
+                minWithdrawAmount: string;
+                maxWithdrawAmount: string;
+                allowTransfer: boolean;
+                minTransferAmount: string;
+                maxTransferAmount: string;
+                allowInternalTransfer: boolean;
+                allowInternalReceiveTransfer: boolean;
+                minInternalTransferAmount: string;
+                maxInternalTransferAmount: string;
+                internalTransferRatio: string;
+                allowTransaction: boolean;
+                hasExpiry: boolean;
+                expiryDays: number | null;
+                sortOrder: number;
+            };
+        }[];
+    } | null>;
+    static listWalletTypesForInternal(options?: WalletTypeListQueryOptions, defaultIsActive?: boolean): Promise<{
+        items: {
+            allowedLedgerAccountTypes: {
+                id: string;
+                key: string;
+                name: string;
+                description: string | null;
+                isActive: boolean;
+            }[];
+            id: string;
+            key: string;
+            name: string;
+            isSingleton: boolean;
+            isActive: boolean;
+            sortOrder: number;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+    }>;
+    static createWalletTypeInternal(input: WalletTypeCreateInputType): Promise<{
+        allowedLedgerAccountTypes: {
+            id: string;
+            key: string;
+            name: string;
+            description: string | null;
+            isActive: boolean;
+        }[];
+        id: string;
+        key: string;
+        name: string;
+        isSingleton: boolean;
+        isActive: boolean;
+        sortOrder: number;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    static updateWalletTypeInternal(key: string, input: WalletTypeUpdateInputType): Promise<{
+        allowedLedgerAccountTypes: {
+            id: string;
+            key: string;
+            name: string;
+            description: string | null;
+            isActive: boolean;
+        }[];
+        id: string;
+        key: string;
+        name: string;
+        isSingleton: boolean;
+        isActive: boolean;
+        sortOrder: number;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    static updateWalletTypeStatusInternal(key: string, isActive: boolean): Promise<{
+        allowedLedgerAccountTypes: {
+            id: string;
+            key: string;
+            name: string;
+            description: string | null;
+            isActive: boolean;
+        }[];
+        id: string;
+        key: string;
+        name: string;
+        isSingleton: boolean;
+        isActive: boolean;
+        sortOrder: number;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+}
+export {};

package/dist/src/wallet-type/permissions.d.ts

@@ -0,0 +1,4 @@
+export declare const walletTypePermissions: {
+    readonly "wallet:type": readonly ["create", "read", "update", "delete", "list"];
+};
+export type WalletTypePermission = keyof typeof walletTypePermissions;