vona-cli-set-api 1.0.496 → 1.1.3

package/cli/templates/create/project/cabloy-start/boilerplate/src/backend/config/config/config.prod.ts

@@ -0,0 +1,36 @@
+import type { VonaApplication, VonaConfigEnv, VonaConfigOptional } from 'vona';
+
+export default async function (_app: VonaApplication, _env: VonaConfigEnv) {
+  const config: VonaConfigOptional = {};
+
+  // instance
+  config.instance = {
+    instances: {
+      '': { password: '', title: '' },
+    },
+  };
+
+  // redis
+  config.redis = {
+    clients: {},
+  };
+
+  // database
+  config.database = {
+    testDatabase: false,
+    base: {
+      asyncStackTraces: false,
+    },
+    clients: {
+      isolateTest: undefined,
+    },
+  };
+
+  // modules
+  config.modules = {};
+
+  // onions
+  config.onions = {};
+
+  return config;
+}

package/cli/templates/create/project/cabloy-start/boilerplate/src/backend/config/config/config.test.ts

@@ -0,0 +1,41 @@
+import type { VonaApplication, VonaConfigEnv, VonaConfigOptional } from 'vona';
+
+export default async function (_app: VonaApplication, _env: VonaConfigEnv) {
+  const config: VonaConfigOptional = {};
+
+  // proxy
+  config.proxy = {
+    enable: false,
+  };
+
+  // instance
+  config.instance = {
+    instances: {
+      '': { password: '', title: '', config: {} },
+      'shareTest': { password: '', title: '' },
+      'isolateTest': { password: '', title: '', id: 1000, isolate: true, isolateClient: 'isolateTest' },
+    },
+  };
+
+  // redis
+  config.redis = {
+    clients: {},
+  };
+
+  // database
+  config.database = {
+    testDatabase: true,
+    base: {
+      pool: { min: 0, max: 1 },
+    },
+    clients: {},
+  };
+
+  // modules
+  config.modules = {};
+
+  // onions
+  config.onions = {};
+
+  return config;
+}

package/cli/templates/create/project/cabloy-start/boilerplate/src/backend/config/config/config.ts

@@ -0,0 +1,201 @@
+import type { ILoggerOptionsClientInfo, VonaApplication, VonaConfigEnv, VonaConfigOptional } from 'vona';
+import type { IMailClientRecord, TypeMailTransportService } from 'vona-module-a-mail';
+import type { IDatabaseClientRecord } from 'vona-module-a-orm';
+
+import { replaceTemplate } from '@cabloy/utils';
+import { $customKey, getLoggerPathPhysicalRoot, getPublicPathPhysicalRoot, getSqlite3DatabaseNameDefault, getSqlite3NativeBinding } from 'vona';
+
+declare module 'vona' {
+  export interface IInstanceRecord {
+    shareTest: never;
+    isolateTest: never;
+  }
+}
+
+declare module 'vona-module-a-orm' {
+  export interface IDatabaseClientRecord {
+    isolateTest: never;
+  }
+}
+
+export default async function (app: VonaApplication, env: VonaConfigEnv) {
+  const config: VonaConfigOptional = {};
+
+  // modules
+  config.modules = {};
+
+  // onions
+  config.onions = {};
+
+  // meta
+  config.meta = {
+    flavor: app.configMeta.flavor,
+    mode: app.configMeta.mode,
+  };
+
+  // instance
+  config.instance = {
+    getInstanceName: undefined,
+    queryField: $customKey('x-vona-instance-name'),
+    headerField: $customKey('x-vona-instance-name'),
+    instances: {},
+  };
+
+  // server
+  const publicDir = env.SERVER_PUBLICDIR || getPublicPathPhysicalRoot(app);
+  const subdomainOffset = Number.parseInt(env.SERVER_SUBDOMAINOFFSET || '1');
+  const workers = Number.parseInt(env.SERVER_WORKERS!);
+  config.server = {
+    keys: (env.SERVER_KEYS || '').split(','),
+    globalPrefix: env.SERVER_GLOBALPREFIX || '/api',
+    publicDir,
+    subdomainOffset,
+    workers,
+    listen: {
+      hostname: env.SERVER_LISTEN_HOSTNAME,
+      port: Number.parseInt(env.SERVER_LISTEN_PORT!),
+      disable: env.SERVER_LISTEN_DISABLE === 'true',
+    },
+    serve: {
+      protocol: env.SERVER_SERVE_PROTOCOL,
+      host: env.SERVER_SERVE_HOST,
+    },
+  };
+
+  // proxy
+  config.proxy = {
+    enable: true,
+    ipHeaders: 'x-real-ip,x-forwarded-for',
+    hostHeaders: 'x-forwarded-host,host',
+    protocolHeaders: 'x-forwarded-proto',
+    maxProxyCount: 1,
+    maxIpsCount: 15,
+  };
+
+  // logger
+  const loggerDir = env.LOGGER_DIR || getLoggerPathPhysicalRoot(app);
+  config.logger = {
+    baseDir: loggerDir,
+    rotate(filename: string) {
+      return {
+        enable: env.LOGGER_ROTATE_ENABLE === 'true',
+        filename: replaceTemplate(env.LOGGER_ROTATE_FILENAME!, { filename }),
+        datePattern: env.LOGGER_ROTATE_DATEPATTERN,
+        maxSize: env.LOGGER_ROTATE_MAXSIZE,
+        maxFiles: env.LOGGER_ROTATE_MAXFILES,
+      };
+    },
+    base(this: VonaApplication) {
+      return {
+        format: this.bean.logger.makeFormatBase({ stack: true }),
+        transports: undefined,
+      };
+    },
+    clients: {
+      default(this: VonaApplication, clientInfo: ILoggerOptionsClientInfo) {
+        const transports = [
+          this.bean.logger.makeTransportFile(clientInfo, 'error', 'error'),
+          this.bean.logger.makeTransportFile(clientInfo, 'warn', 'warn'),
+          this.bean.logger.makeTransportFile(clientInfo, 'http', 'http'),
+          this.bean.logger.makeTransportFile(clientInfo, 'combined'),
+          this.bean.logger.makeTransportConsole(clientInfo),
+        ];
+        return { transports };
+      },
+    },
+  };
+
+  // redis
+  config.redis = {
+    base: {
+      host: env.REDIS_DEFAULT_HOST,
+      port: Number.parseInt(env.REDIS_DEFAULT_PORT!),
+      password: env.REDIS_DEFAULT_PASSWORD,
+      db: Number.parseInt(env.REDIS_DEFAULT_DB!),
+      maxRetriesPerRequest: null,
+      enableReadyCheck: false,
+    },
+    clients: {
+      default: { keyPrefix: true },
+      cache: { keyPrefix: true },
+      io: { keyPrefix: true },
+      summer: { keyPrefix: true },
+      model: { keyPrefix: true },
+      worker: { keyPrefix: true },
+      redlock: {},
+      queue: {},
+      broadcast: {},
+    },
+  };
+
+  // database
+  config.database = {
+    testDatabase: false,
+    base: {
+      pool: { min: 0, max: 5 },
+      acquireConnectionTimeout: 60000 * 10,
+      asyncStackTraces: true,
+    },
+    defaultClient: env.DATABASE_DEFAULT_CLIENT as keyof IDatabaseClientRecord,
+    clients: {
+      sqlite3: {
+        client: 'better-sqlite3',
+        connection: {
+          filename: env.DATABASE_CLIENT_SQLITE3_FILENAME || getSqlite3DatabaseNameDefault(app),
+          options: {
+            nativeBinding: getSqlite3NativeBinding(app, env.DATABASE_CLIENT_SQLITE3_NATIVEBINDING),
+          },
+        },
+      },
+      pg: {
+        client: 'pg',
+        connection: {
+          host: env.DATABASE_CLIENT_PG_HOST,
+          port: Number.parseInt(env.DATABASE_CLIENT_PG_PORT!),
+          user: env.DATABASE_CLIENT_PG_USER,
+          password: env.DATABASE_CLIENT_PG_PASSWORD,
+          database: env.DATABASE_CLIENT_PG_DATABASE,
+        },
+      },
+      mysql: {
+        client: 'mysql2',
+        connection: {
+          host: env.DATABASE_CLIENT_MYSQL_HOST,
+          port: Number.parseInt(env.DATABASE_CLIENT_MYSQL_PORT!),
+          user: env.DATABASE_CLIENT_MYSQL_USER,
+          password: env.DATABASE_CLIENT_MYSQL_PASSWORD,
+          database: env.DATABASE_CLIENT_MYSQL_DATABASE,
+        },
+      },
+    },
+  };
+
+  // Multi-Instance/Multi-Tenancy
+  config.database.clients!.isolateTest = {
+    ...config.database.clients![env.DATABASE_DEFAULT_CLIENT as keyof IDatabaseClientRecord],
+  };
+
+  // mail
+  config.modules['a-mail'] = {
+    defaultClient: env.MAIL_DEFAULT_CLIENT as keyof IMailClientRecord,
+    clients: {
+      system: {
+        transport: {
+          service: (env.MAIL_SYSTEM_TRANSPORT_SERVICE as TypeMailTransportService) || undefined,
+          host: env.MAIL_SYSTEM_TRANSPORT_HOST || undefined,
+          port: env.MAIL_SYSTEM_TRANSPORT_PORT ? Number.parseInt(env.MAIL_SYSTEM_TRANSPORT_PORT) : undefined,
+          secure: env.MAIL_SYSTEM_TRANSPORT_SECURE === 'true',
+          auth: {
+            user: env.MAIL_SYSTEM_TRANSPORT_AUTH_USER || undefined,
+            pass: env.MAIL_SYSTEM_TRANSPORT_AUTH_PASS || undefined,
+          },
+        },
+        defaults: {
+          from: env.MAIL_SYSTEM_DEFAULTS_FROM || undefined,
+        },
+      },
+    },
+  };
+
+  return config;
+}

package/cli/templates/create/project/cabloy-start/boilerplate/src/backend/config/locale/en-us.ts

@@ -0,0 +1,8 @@
+import type { VonaLocaleOptional } from 'vona';
+
+const localeDefault = {};
+
+const localeModules: VonaLocaleOptional = {};
+localeModules.modules = {};
+
+export { localeDefault, localeModules };

package/cli/templates/create/project/cabloy-start/boilerplate/src/backend/config/locale/zh-cn.ts

@@ -0,0 +1,8 @@
+import type { VonaLocaleOptional } from 'vona';
+
+const localeDefault = {};
+
+const localeModules: VonaLocaleOptional = {};
+localeModules.modules = {};
+
+export { localeDefault, localeModules };

package/cli/templates/create/project/cabloy-start/boilerplate/src/backend/config/locales.ts

@@ -0,0 +1,20 @@
+import type { TypeLocaleBase, VonaLocaleOptionalMap } from 'vona';
+
+import { $makeLocaleMagic } from 'vona';
+
+import { localeDefault as localeDefault_en_us, localeModules as localeModules_en_us } from './locale/en-us.ts';
+import { localeDefault as localeDefault_zh_cn, localeModules as localeModules_zh_cn } from './locale/zh-cn.ts';
+
+export const localesDefault = {
+  'en-us': localeDefault_en_us,
+  'zh-cn': localeDefault_zh_cn,
+};
+
+export const localesModules: VonaLocaleOptionalMap = {
+  'en-us': localeModules_en_us,
+  'zh-cn': localeModules_zh_cn,
+};
+
+export function $localeDefault<K extends keyof (typeof localesDefault)[TypeLocaleBase]>(key: K, ...args: any[]): any {
+  return $makeLocaleMagic(`::${key}`, ...args);
+}

package/cli/templates/create/project/cabloy-start/boilerplate/src/backend/typing/env.d.ts

@@ -0,0 +1,5 @@
+// eslint-disable
+
+declare namespace NodeJS {
+  interface ProcessEnv {}
+}

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-base/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "vona-module-home-base",
+  "version": "5.1.1",
+  "description": "",
+  "keywords": [
+    "Vona Module"
+  ],
+  "author": "",
+  "files": [
+    "assets",
+    "dist",
+    "src"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": [
+        "./src/index.ts",
+        "./dist/index.d.ts"
+      ],
+      "import": "./src/index.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "clean": "rimraf dist tsconfig.build.tsbuildinfo",
+    "tsc:publish": "npm run clean && vona :bin:buildModule --sourcemap && tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run tsc:publish",
+    "prepack": "clean-package",
+    "postpack": "clean-package restore && npm run clean",
+    "version": "node ../../../../../scripts/version-home.ts"
+  },
+  "devDependencies": {
+    "clean-package": "^2.2.0",
+    "rimraf": "^6.0.1"
+  },
+  "clean-package": {
+    "indent": 2,
+    "remove": [
+      "clean-package",
+      "exports.\\..import"
+    ]
+  },
+  "title": "home-base",
+  "vonaModule": {
+    "dependencies": {
+      "a-vona": "5.0.0"
+    }
+  }
+}

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-base/src/.metadata/index.ts

@@ -0,0 +1,155 @@
+// eslint-disable
+import type { TypeControllerOptionsActions } from 'vona-module-a-openapi';
+/** service: begin */
+export * from '../service/menu.ts';
+export * from '../service/permission.ts';
+
+import 'vona-module-a-bean';
+declare module 'vona-module-a-bean' {
+  
+    export interface IServiceRecord {
+      'home-base:menu': never;
+'home-base:permission': never;
+    }
+
+  
+}
+declare module 'vona-module-home-base' {
+  
+        export interface ServiceMenu {
+          /** @internal */
+          get scope(): ScopeModuleHomeBase;
+        }
+
+          export interface ServiceMenu {
+            get $beanFullName(): 'home-base.service.menu';
+            get $onionName(): 'home-base:menu';
+            
+          }
+
+        export interface ServicePermission {
+          /** @internal */
+          get scope(): ScopeModuleHomeBase;
+        }
+
+          export interface ServicePermission {
+            get $beanFullName(): 'home-base.service.permission';
+            get $onionName(): 'home-base:permission';
+            
+          } 
+}
+/** service: end */
+/** service: begin */
+import type { ServiceMenu } from '../service/menu.ts';
+import type { ServicePermission } from '../service/permission.ts';
+export interface IModuleService {
+  'menu': ServiceMenu;
+'permission': ServicePermission;
+}
+/** service: end */
+/** service: begin */
+
+import 'vona';
+declare module 'vona' {
+  export interface IBeanRecordGeneral {
+    'home-base.service.menu': ServiceMenu;
+'home-base.service.permission': ServicePermission;
+  }
+}
+/** service: end */
+/** controller: begin */
+export * from '../controller/menu.ts';
+export * from '../controller/permission.ts';
+import type { IControllerOptionsMenu } from '../controller/menu.ts';
+import type { IControllerOptionsPermission } from '../controller/permission.ts';
+import 'vona-module-a-web';
+declare module 'vona-module-a-web' {
+  
+    export interface IControllerRecord {
+      'home-base:menu': IControllerOptionsMenu;
+'home-base:permission': IControllerOptionsPermission;
+    }
+
+  
+}
+declare module 'vona-module-home-base' {
+  
+        export interface ControllerMenu {
+          /** @internal */
+          get scope(): ScopeModuleHomeBase;
+        }
+
+          export interface ControllerMenu {
+            get $beanFullName(): 'home-base.controller.menu';
+            get $onionName(): 'home-base:menu';
+            get $onionOptions(): IControllerOptionsMenu;
+          }
+
+        export interface ControllerPermission {
+          /** @internal */
+          get scope(): ScopeModuleHomeBase;
+        }
+
+          export interface ControllerPermission {
+            get $beanFullName(): 'home-base.controller.permission';
+            get $onionName(): 'home-base:permission';
+            get $onionOptions(): IControllerOptionsPermission;
+          } 
+}
+/** controller: end */
+/** controller: begin */
+// @ts-ignore ignore
+import type { ControllerMenu } from '../controller/menu.ts';
+// @ts-ignore ignore
+import type { ControllerPermission } from '../controller/permission.ts';
+declare module 'vona-module-home-base' {
+  
+    export interface IControllerOptionsMenu {
+      actions?: TypeControllerOptionsActions<ControllerMenu>;
+    }
+
+    export interface IControllerOptionsPermission {
+      actions?: TypeControllerOptionsActions<ControllerPermission>;
+    }
+}
+declare module 'vona-module-a-web' {
+  export interface IApiPathGetRecord{
+        '/home/base/menu/:publicPath?': undefined;
+'/home/base/permission/:resource': undefined;
+    }
+
+}
+
+/** controller: end */
+/** main: begin */
+export * from '../main.ts';
+/** main: end */
+/** scope: begin */
+import { BeanScopeBase, type BeanScopeUtil } from 'vona';
+import { Scope } from 'vona-module-a-bean';
+
+@Scope()
+export class ScopeModuleHomeBase extends BeanScopeBase {}
+
+export interface ScopeModuleHomeBase {
+  util: BeanScopeUtil;
+service: IModuleService;
+}
+
+import 'vona';
+declare module 'vona' {
+  export interface IBeanScopeRecord {
+    'home-base': ScopeModuleHomeBase;
+  }
+
+  export interface IBeanScopeContainer {
+    homeBase: ScopeModuleHomeBase;
+  }
+  
+  
+
+  
+
+  
+}
+/** scope: end */

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-base/src/.metadata/this.ts

@@ -0,0 +1,2 @@
+export const __ThisModule__ = 'home-base';
+export { ScopeModuleHomeBase as ScopeModule } from './index.ts';

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-base/src/controller/menu.ts

@@ -0,0 +1,20 @@
+import type { IMenus } from 'vona-module-a-menu';
+import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+
+import { BeanBase } from 'vona';
+import { DtoMenus } from 'vona-module-a-menu';
+import { Api, v } from 'vona-module-a-openapiutils';
+import { Passport } from 'vona-module-a-user';
+import { Arg, Controller, Web } from 'vona-module-a-web';
+
+export interface IControllerOptionsMenu extends IDecoratorControllerOptions {}
+
+@Controller<IControllerOptionsMenu>('menu')
+export class ControllerMenu extends BeanBase {
+  @Web.get(':publicPath?')
+  @Api.body(v.object(DtoMenus))
+  @Passport.public()
+  async retrieveMenus(@Arg.param('publicPath', v.optional()) publicPath?: string): Promise<IMenus> {
+    return await this.scope.service.menu.retrieveMenus(publicPath);
+  }
+}

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-base/src/controller/permission.ts

@@ -0,0 +1,19 @@
+import type { IOpenapiPermissions, IResourceRecord } from 'vona-module-a-openapi';
+import type { IDecoratorControllerOptions } from 'vona-module-a-web';
+
+import { BeanBase } from 'vona';
+import { Api, v } from 'vona-module-a-openapiutils';
+import { DtoPermissions } from 'vona-module-a-permission';
+import { Arg, Controller, Web } from 'vona-module-a-web';
+import z from 'zod';
+
+export interface IControllerOptionsPermission extends IDecoratorControllerOptions {}
+
+@Controller<IControllerOptionsPermission>('permission')
+export class ControllerPermission extends BeanBase {
+  @Web.get(':resource')
+  @Api.body(v.object(DtoPermissions))
+  async retrievePermissions(@Arg.param('resource', z.string()) resource: keyof IResourceRecord): Promise<IOpenapiPermissions> {
+    return await this.scope.service.permission.retrievePermissions(resource);
+  }
+}

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-base/src/index.ts

@@ -0,0 +1 @@
+export * from './.metadata/index.ts';

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-base/src/main.ts

@@ -0,0 +1,17 @@
+import type { IModuleMain } from 'vona';
+
+import { BeanSimple } from 'vona';
+import { en, zhCN } from 'zod/locales';
+
+export class Main extends BeanSimple implements IModuleMain {
+  async moduleLoading() {}
+  async moduleLoaded() {
+    const localeErrors = {
+      'en-us': en,
+      'zh-cn': zhCN,
+    };
+    this.app.util.setLocaleErrors(localeErrors, this.app.scope('a-locale').config.locale.defaultLocale);
+  }
+
+  async configLoaded(_config: any) {}
+}

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-base/src/service/menu.ts

@@ -0,0 +1,19 @@
+import type { IMenus } from 'vona-module-a-menu';
+
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+@Service()
+export class ServiceMenu extends BeanBase {
+  async retrieveMenus(publicPath?: string): Promise<IMenus> {
+    const res = await this.bean.ssr.retrieveMenus(publicPath);
+    if (res) return res;
+    return this._getMenusDefault();
+  }
+
+  private _getMenusDefault(): IMenus {
+    return {
+      menus: [{ name: 'home', title: this.$scope.homeIndex.locale.Home(), icon: '::home', link: '/' }],
+    };
+  }
+}

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-base/src/service/permission.ts

@@ -0,0 +1,11 @@
+import type { IOpenapiPermissions, IResourceRecord } from 'vona-module-a-openapi';
+
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+@Service()
+export class ServicePermission extends BeanBase {
+  async retrievePermissions(resource: keyof IResourceRecord): Promise<IOpenapiPermissions> {
+    return await this.bean.permission.retrievePermissions(resource);
+  }
+}

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-base/tsconfig.build.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base",
+  "compilerOptions": {
+    "rootDir": "src",
+    "declaration": true,
+    "declarationMap": true,
+    "emitDeclarationOnly": true,
+    "outDir": "dist"
+  },
+  "include": ["src", "src/.metadata/*.ts", "src/**/*.json"]
+}

package/cli/templates/create/project/cabloy-start/boilerplate/src/suite/a-home/modules/home-base/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.base",
+  "compilerOptions": {
+    "noEmit": true
+  },
+  "include": ["src", "src/.metadata/*.ts", "src/**/*.json", "test"]
+}