vona-module-test-vona 5.0.11 → 5.0.13

package/dist/.metadata/index.d.ts

@@ -0,0 +1,551 @@
+import type { BeanScopeUtil, TypeLocaleBase, TypeModuleConfig, TypeModuleLocales } from 'vona';
+import type { IDecoratorAopOptions } from 'vona-module-a-aspect';
+import type { IDecoratorBroadcastOptions } from 'vona-module-a-broadcast';
+import type { IDecoratorCacheMemOptions } from 'vona-module-a-cache';
+import type { IDecoratorCacheRedisOptions } from 'vona-module-a-cache';
+import type { IDecoratorModelOptions } from 'vona-module-a-database';
+import type { EventOn } from 'vona-module-a-event';
+import type { IDecoratorEventListenerOptions } from 'vona-module-a-event';
+import type { TypeControllerOptionsActions } from 'vona-module-a-openapi';
+import type { TypeEntityOptionsFields } from 'vona-module-a-openapi';
+import type { IDecoratorQueueOptions } from 'vona-module-a-queue';
+import type { IDecoratorScheduleOptions } from 'vona-module-a-schedule';
+import type { IDecoratorSummerCacheOptions } from 'vona-module-a-summer';
+import type { IAopMethodOptionsTest } from '../bean/aopMethod.test.ts';
+/** bean: end */
+/** bean: begin */
+import type { BeanTestCtx } from '../bean/bean.testCtx.ts';
+/** broadcast: end */
+/** broadcast: begin */
+import type { BroadcastTest } from '../bean/broadcast.test.ts';
+/** cacheMem: end */
+/** cacheMem: begin */
+import type { CacheMemTest } from '../bean/cacheMem.test.ts';
+/** cacheRedis: end */
+/** cacheRedis: begin */
+import type { CacheRedisTest } from '../bean/cacheRedis.test.ts';
+/** event: end */
+/** event: begin */
+import type { EventHelloEcho } from '../bean/event.helloEcho.ts';
+/** event: end */
+/** event: begin */
+import type { TypeEventHelloEchoData, TypeEventHelloEchoResult } from '../bean/event.helloEcho.ts';
+/** queue: end */
+/** queue: begin */
+import type { QueueTest } from '../bean/queue.test.ts';
+/** summerCache: end */
+/** summerCache: begin */
+import type { SummerCacheTest } from '../bean/summerCache.test.ts';
+import type { config } from '../config/config.ts';
+import type { IControllerOptionsBean } from '../controller/bean.ts';
+/** controller: end */
+/** controller: begin */
+import '../controller/bean.ts';
+import type { IControllerOptionsCacheMem } from '../controller/cacheMem.ts';
+import '../controller/cacheMem.ts';
+import type { IControllerOptionsCacheRedis } from '../controller/cacheRedis.ts';
+import '../controller/cacheRedis.ts';
+import type { IControllerOptionsOnion } from '../controller/onion.ts';
+import '../controller/onion.ts';
+import type { IControllerOptionsPassport } from '../controller/passport.ts';
+import '../controller/passport.ts';
+import type { IControllerOptionsPerformAction } from '../controller/performAction.ts';
+import '../controller/performAction.ts';
+import type { IControllerOptionsQueue } from '../controller/queue.ts';
+import '../controller/queue.ts';
+import type { IControllerOptionsSummer } from '../controller/summer.ts';
+import '../controller/summer.ts';
+import type { IControllerOptionsTail } from '../controller/tail.ts';
+import '../controller/tail.ts';
+/** service: end */
+/** service: begin */
+import type { IControllerOptionsTransaction } from '../controller/transaction.ts';
+import '../controller/transaction.ts';
+import type { IControllerOptionsUpload } from '../controller/upload.ts';
+import '../controller/upload.ts';
+import type { IDtoOptionsProfile } from '../dto/profile.ts';
+/** dto: end */
+/** dto: begin */
+import type { DtoProfile } from '../dto/profile.ts';
+import type { IDtoOptionsUser } from '../dto/user.ts';
+import type { DtoUser } from '../dto/user.ts';
+import type { IEntityOptionsTest } from '../entity/test.ts';
+/** entity: end */
+/** entity: begin */
+import type { EntityTest } from '../entity/test.ts';
+/** model: end */
+/** model: begin */
+import type { ModelTest } from '../model/test.ts';
+/** service: end */
+/** service: begin */
+import type { ServiceAopMethod } from '../service/aopMethod.ts';
+import type { ServiceTest } from '../service/test.ts';
+import type { ServiceTestApp } from '../service/testApp.ts';
+import type { ServiceTestClass } from '../service/testClass.ts';
+import type { ServiceTransaction } from '../service/transaction.ts';
+/** locale: end */
+/** scope: begin */
+import { BeanScopeBase } from 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+/** aop: begin */
+export * from '../bean/aop.regExp.ts';
+export * from '../bean/aop.simple.ts';
+declare module 'vona-module-a-aspect' {
+    interface IAopRecord {
+        'test-vona:regExp': IDecoratorAopOptions;
+        'test-vona:simple': IDecoratorAopOptions;
+    }
+}
+declare module 'vona-module-test-vona' {
+    interface AopRegExp {
+    }
+    interface AopSimple {
+    }
+}
+/** aop: end */
+/** aopMethod: begin */
+export * from '../bean/aopMethod.test.ts';
+declare module 'vona-module-a-aspect' {
+    interface IAopMethodRecord {
+        'test-vona:test': IAopMethodOptionsTest;
+    }
+}
+declare module 'vona-module-test-vona' {
+    interface AopMethodTest {
+    }
+}
+/** model: end */
+/** bean: begin */
+export * from '../bean/bean.testCtx.ts';
+declare module 'vona-module-a-database' {
+    interface IEntityRecord {
+        'test-vona:test': IEntityOptionsTest;
+    }
+}
+declare module 'vona-module-test-vona' {
+}
+export interface IModuleEntity {
+    test: EntityTest;
+}
+/** entity: end */
+/** entity: begin */
+declare module 'vona-module-test-vona' {
+    interface EntityTest {
+        $column: <K extends keyof Omit<EntityTest, '$column' | '$columns' | '$table'>>(column: K) => K;
+        $columns: <K extends keyof Omit<EntityTest, '$column' | '$columns' | '$table'>>(...columns: K[]) => K[];
+    }
+    interface IEntityOptionsTest {
+        fields?: TypeEntityOptionsFields<EntityTest, IEntityOptionsTest['fieldsMore']>;
+    }
+}
+/** bean: end */
+/** broadcast: begin */
+export * from '../bean/broadcast.test.ts';
+declare module 'vona-module-a-database' {
+    interface IModelRecord {
+        'test-vona:test': IDecoratorModelOptions;
+    }
+}
+declare module 'vona-module-test-vona' {
+    interface ModelTest {
+    }
+}
+export interface IModuleModel {
+    test: ModelTest;
+}
+/** broadcast: end */
+/** cacheMem: begin */
+export * from '../bean/cacheMem.test.ts';
+declare module 'vona' {
+}
+declare module 'vona-module-test-vona' {
+    interface BeanTestCtx {
+    }
+}
+declare module 'vona' {
+    interface IBeanRecordGlobal {
+        testCtx: BeanTestCtx;
+    }
+}
+/** cacheMem: end */
+/** cacheRedis: begin */
+export * from '../bean/cacheRedis.test.ts';
+declare module 'vona-module-a-broadcast' {
+    interface IBroadcastRecord {
+        'test-vona:test': IDecoratorBroadcastOptions;
+    }
+}
+declare module 'vona-module-test-vona' {
+    interface BroadcastTest {
+    }
+}
+export interface IModuleBroadcast {
+    test: BroadcastTest;
+}
+/** cacheRedis: end */
+/** event: begin */
+export * from '../bean/event.helloEcho.ts';
+declare module 'vona-module-a-cache' {
+    interface ICacheMemRecord {
+        'test-vona:test': IDecoratorCacheMemOptions;
+    }
+}
+declare module 'vona-module-test-vona' {
+    interface CacheMemTest {
+    }
+}
+export interface IModuleCacheMem {
+    test: CacheMemTest;
+}
+/** event: end */
+/** eventListener: begin */
+export * from '../bean/eventListener.helloEcho.ts';
+declare module 'vona-module-a-cache' {
+    interface ICacheRedisRecord {
+        'test-vona:test': IDecoratorCacheRedisOptions;
+    }
+}
+declare module 'vona-module-test-vona' {
+    interface CacheRedisTest {
+    }
+}
+export interface IModuleCacheRedis {
+    test: CacheRedisTest;
+}
+/** eventListener: end */
+/** meta: begin */
+export * from '../bean/meta.version.ts';
+declare module 'vona' {
+}
+declare module 'vona-module-test-vona' {
+    interface EventHelloEcho {
+    }
+}
+export interface IModuleEvent {
+    helloEcho: EventHelloEcho;
+}
+declare module 'vona-module-a-event' {
+    interface IEventRecord {
+        'test-vona:helloEcho': EventOn<TypeEventHelloEchoData, TypeEventHelloEchoResult>;
+    }
+}
+/** meta: end */
+/** queue: begin */
+export * from '../bean/queue.test.ts';
+declare module 'vona-module-a-event' {
+    interface IEventListenerRecord {
+        'test-vona:helloEcho': IDecoratorEventListenerOptions;
+    }
+}
+declare module 'vona-module-test-vona' {
+    interface EventListenerHelloEcho {
+    }
+}
+export * from '../bean/schedule.test3.ts';
+declare module 'vona' {
+    interface IMetaRecord {
+        'test-vona:version': never;
+    }
+}
+declare module 'vona-module-test-vona' {
+    interface MetaVersion {
+    }
+}
+/** queue: end */
+/** schedule: begin */
+export * from '../bean/schedule.test.ts';
+declare module 'vona-module-a-queue' {
+    interface IQueueRecord {
+        'test-vona:test': IDecoratorQueueOptions;
+    }
+}
+declare module 'vona-module-test-vona' {
+    interface QueueTest {
+    }
+}
+export interface IModuleQueue {
+    test: QueueTest;
+}
+/** schedule: end */
+/** summerCache: begin */
+export * from '../bean/summerCache.test.ts';
+/** controller: end */
+/** config: begin */
+export * from '../config/config.ts';
+declare module 'vona-module-a-schedule' {
+    interface IScheduleRecord {
+        'test-vona:test': IDecoratorScheduleOptions;
+        'test-vona:test3': IDecoratorScheduleOptions;
+    }
+}
+declare module 'vona-module-test-vona' {
+    interface ScheduleTest {
+    }
+    interface ScheduleTest3 {
+    }
+}
+/** service: end */
+/** controller: begin */
+export * from '../controller/bean.ts';
+declare module 'vona-module-a-summer' {
+    interface ISummerCacheRecord {
+        'test-vona:test': IDecoratorSummerCacheOptions;
+    }
+}
+declare module 'vona-module-test-vona' {
+    interface SummerCacheTest {
+    }
+}
+export interface IModuleSummerCache {
+    test: SummerCacheTest;
+}
+export * from '../controller/cacheMem.ts';
+export * from '../controller/cacheRedis.ts';
+declare module 'vona-module-a-web' {
+    interface IDtoRecord {
+        'test-vona:profile': IDtoOptionsProfile;
+        'test-vona:user': IDtoOptionsUser;
+    }
+}
+declare module 'vona-module-test-vona' {
+}
+declare module 'vona-module-test-vona' {
+    interface IDtoOptionsProfile {
+        fields?: TypeEntityOptionsFields<DtoProfile, IDtoOptionsProfile['fieldsMore']>;
+    }
+    interface IDtoOptionsUser {
+        fields?: TypeEntityOptionsFields<DtoUser, IDtoOptionsUser['fieldsMore']>;
+    }
+}
+export * from '../controller/onion.ts';
+export * from '../controller/passport.ts';
+export * from '../controller/performAction.ts';
+export * from '../controller/queue.ts';
+export * from '../controller/summer.ts';
+declare module 'vona-module-a-web' {
+    interface IServiceRecord {
+        'test-vona:aopMethod': never;
+        'test-vona:test': never;
+        'test-vona:testApp': never;
+        'test-vona:testClass': never;
+        'test-vona:transaction': never;
+    }
+}
+declare module 'vona-module-test-vona' {
+    interface ServiceAopMethod {
+    }
+    interface ServiceTest {
+    }
+    interface ServiceTestApp {
+    }
+    interface ServiceTestClass {
+    }
+    interface ServiceTransaction {
+    }
+}
+export interface IModuleService {
+    aopMethod: ServiceAopMethod;
+    test: ServiceTest;
+    testApp: ServiceTestApp;
+    testClass: ServiceTestClass;
+    transaction: ServiceTransaction;
+}
+declare module 'vona' {
+    interface IBeanRecordGeneral {
+        'test-vona.service.aopMethod': ServiceAopMethod;
+        'test-vona.service.test': ServiceTest;
+        'test-vona.service.testApp': ServiceTestApp;
+        'test-vona.service.testClass': ServiceTestClass;
+        'test-vona.service.transaction': ServiceTransaction;
+    }
+}
+export * from '../controller/tail.ts';
+export * from '../controller/transaction.ts';
+export * from '../controller/upload.ts';
+/** summerCache: end */
+/** dto: begin */
+export * from '../dto/profile.ts';
+export * from '../dto/user.ts';
+/** aopMethod: end */
+/** entity: begin */
+export * from '../entity/test.ts';
+/** entity: end */
+/** model: begin */
+export * from '../model/test.ts';
+/** dto: end */
+/** service: begin */
+export * from '../service/aopMethod.ts';
+export * from '../service/test.ts';
+export * from '../service/testApp.ts';
+export * from '../service/testClass.ts';
+declare module 'vona-module-a-web' {
+    interface IControllerRecord {
+        'test-vona:bean': IControllerOptionsBean;
+        'test-vona:cacheMem': IControllerOptionsCacheMem;
+        'test-vona:cacheRedis': IControllerOptionsCacheRedis;
+        'test-vona:onion': IControllerOptionsOnion;
+        'test-vona:passport': IControllerOptionsPassport;
+        'test-vona:performAction': IControllerOptionsPerformAction;
+        'test-vona:queue': IControllerOptionsQueue;
+        'test-vona:summer': IControllerOptionsSummer;
+        'test-vona:tail': IControllerOptionsTail;
+        'test-vona:transaction': IControllerOptionsTransaction;
+        'test-vona:upload': IControllerOptionsUpload;
+    }
+}
+declare module 'vona-module-test-vona' {
+    interface ControllerBean {
+    }
+    interface ControllerCacheMem {
+    }
+    interface ControllerCacheRedis {
+    }
+    interface ControllerOnion {
+    }
+    interface ControllerPassport {
+    }
+    interface ControllerPerformAction {
+    }
+    interface ControllerQueue {
+    }
+    interface ControllerSummer {
+    }
+    interface ControllerTail {
+    }
+    interface ControllerTransaction {
+    }
+    interface ControllerUpload {
+    }
+}
+declare module 'vona-module-test-vona' {
+    interface IControllerOptionsBean {
+        actions?: TypeControllerOptionsActions<ControllerBean>;
+    }
+    interface IControllerOptionsCacheMem {
+        actions?: TypeControllerOptionsActions<ControllerCacheMem>;
+    }
+    interface IControllerOptionsCacheRedis {
+        actions?: TypeControllerOptionsActions<ControllerCacheRedis>;
+    }
+    interface IControllerOptionsOnion {
+        actions?: TypeControllerOptionsActions<ControllerOnion>;
+    }
+    interface IControllerOptionsPassport {
+        actions?: TypeControllerOptionsActions<ControllerPassport>;
+    }
+    interface IControllerOptionsPerformAction {
+        actions?: TypeControllerOptionsActions<ControllerPerformAction>;
+    }
+    interface IControllerOptionsQueue {
+        actions?: TypeControllerOptionsActions<ControllerQueue>;
+    }
+    interface IControllerOptionsSummer {
+        actions?: TypeControllerOptionsActions<ControllerSummer>;
+    }
+    interface IControllerOptionsTail {
+        actions?: TypeControllerOptionsActions<ControllerTail>;
+    }
+    interface IControllerOptionsTransaction {
+        actions?: TypeControllerOptionsActions<ControllerTransaction>;
+    }
+    interface IControllerOptionsUpload {
+        actions?: TypeControllerOptionsActions<ControllerUpload>;
+    }
+}
+declare module 'vona-module-a-web' {
+    interface IApiPathGetRecord {
+        '/test/vona/bean/test': undefined;
+        '/test/vona/bean/service': undefined;
+        '/': undefined;
+        '/test/vona/onion/echo3/:userId': undefined;
+        '/test/vona/onion/echo5': undefined;
+        '/test/vona/onion/echo6': undefined;
+        '/test/vona/passport/echo/:name': undefined;
+        '/test/vona/passport/isAuthenticated': undefined;
+    }
+    interface IApiPathPostRecord {
+        '/test/vona/cacheMem': undefined;
+        '/test/vona/cacheRedis': undefined;
+        '//echo': undefined;
+        '/test/vona/onion/echo2/:userId/:userName': undefined;
+        '/test/vona/onion/echo4': undefined;
+        '/test/vona/passport/login': undefined;
+        '/test/vona/passport/refresh': undefined;
+        '/test/vona/passport/logout': undefined;
+        '/test/vona/performAction/echo': undefined;
+        '/test/vona/queue/pushAsync': undefined;
+        '/test/vona/queue/push': undefined;
+        '/test/vona/summer': undefined;
+        '/test/vona/tail': undefined;
+        '/test/vona/transaction/fail': undefined;
+        '/test/vona/transaction/success': undefined;
+        '/test/vona/upload/fields': undefined;
+        '/test/vona/upload/file': undefined;
+        '/test/vona/upload/files': undefined;
+    }
+}
+export * from '../service/transaction.ts';
+export declare const locales: {
+    'en-us': {
+        User: string;
+        UserId: string;
+        TestHelloWorld: string;
+        TestApples: string;
+        TestApples_0: string;
+        TestApples_1: string;
+        TestNameApples_: string;
+        TestNameApples_0_1: string;
+        TestNameApples_1_1: string;
+    };
+    'zh-cn': {
+        User: string;
+        UserId: string;
+        TestHelloWorld: string;
+        TestApples: string;
+        TestApples_0: string;
+        TestNameApples_: string;
+        TestNameApples_0_1: string;
+    };
+};
+export declare class ScopeModuleTestVona extends BeanScopeBase {
+}
+export interface ScopeModuleTestVona {
+    util: BeanScopeUtil;
+    config: TypeModuleConfig<typeof config>;
+    locale: TypeModuleLocales<(typeof locales)[TypeLocaleBase]>;
+    entity: IModuleEntity;
+    model: IModuleModel;
+    broadcast: IModuleBroadcast;
+    cacheMem: IModuleCacheMem;
+    cacheRedis: IModuleCacheRedis;
+    event: IModuleEvent;
+    queue: IModuleQueue;
+    summerCache: IModuleSummerCache;
+    service: IModuleService;
+}
+declare module 'vona' {
+    interface IBeanScopeRecord {
+        'test-vona': ScopeModuleTestVona;
+    }
+    interface IBeanScopeContainer {
+        testVona: ScopeModuleTestVona;
+    }
+    interface IBeanScopeConfig {
+        'test-vona': ReturnType<typeof config>;
+    }
+    interface IBeanScopeLocale {
+        'test-vona': (typeof locales)[TypeLocaleBase];
+    }
+}
+export declare function $locale<K extends keyof (typeof locales)[TypeLocaleBase]>(key: K): `test-vona::${K}`;
+/** scope: end */

package/dist/.metadata/index.js

@@ -0,0 +1,109 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+/** locale: end */
+/** scope: begin */
+import { BeanScopeBase } from 'vona';
+import { Scope } from 'vona-module-a-bean';
+/** config: end */
+/** locale: begin */
+import locale_en_us from "../config/locale/en-us.js";
+import locale_zh_cn from "../config/locale/zh-cn.js";
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+/** aop: begin */
+export * from "../bean/aop.regExp.js";
+export * from "../bean/aop.simple.js";
+/** aop: end */
+/** aopMethod: begin */
+export * from "../bean/aopMethod.test.js";
+/** model: end */
+/** bean: begin */
+export * from "../bean/bean.testCtx.js";
+/** bean: end */
+/** broadcast: begin */
+export * from "../bean/broadcast.test.js";
+/** broadcast: end */
+/** cacheMem: begin */
+export * from "../bean/cacheMem.test.js";
+/** cacheMem: end */
+/** cacheRedis: begin */
+export * from "../bean/cacheRedis.test.js";
+/** cacheRedis: end */
+/** event: begin */
+export * from "../bean/event.helloEcho.js";
+/** event: end */
+/** eventListener: begin */
+export * from "../bean/eventListener.helloEcho.js";
+/** eventListener: end */
+/** meta: begin */
+export * from "../bean/meta.version.js";
+/** meta: end */
+/** queue: begin */
+export * from "../bean/queue.test.js";
+export * from "../bean/schedule.test3.js";
+/** queue: end */
+/** schedule: begin */
+export * from "../bean/schedule.test.js";
+/** schedule: end */
+/** summerCache: begin */
+export * from "../bean/summerCache.test.js";
+/** controller: end */
+/** config: begin */
+export * from "../config/config.js";
+/** service: end */
+/** controller: begin */
+export * from "../controller/bean.js";
+export * from "../controller/cacheMem.js";
+export * from "../controller/cacheRedis.js";
+export * from "../controller/onion.js";
+export * from "../controller/passport.js";
+export * from "../controller/performAction.js";
+export * from "../controller/queue.js";
+export * from "../controller/summer.js";
+export * from "../controller/tail.js";
+export * from "../controller/transaction.js";
+export * from "../controller/upload.js";
+/** summerCache: end */
+/** dto: begin */
+export * from "../dto/profile.js";
+export * from "../dto/user.js";
+/** aopMethod: end */
+/** entity: begin */
+export * from "../entity/test.js";
+/** entity: end */
+/** model: begin */
+export * from "../model/test.js";
+/** dto: end */
+/** service: begin */
+export * from "../service/aopMethod.js";
+export * from "../service/test.js";
+export * from "../service/testApp.js";
+export * from "../service/testClass.js";
+export * from "../service/transaction.js";
+export const locales = {
+    'en-us': locale_en_us,
+    'zh-cn': locale_zh_cn,
+};
+let ScopeModuleTestVona = class ScopeModuleTestVona extends BeanScopeBase {
+};
+ScopeModuleTestVona = __decorate([
+    Scope()
+], ScopeModuleTestVona);
+export { ScopeModuleTestVona };
+export function $locale(key) {
+    return `test-vona::${key}`;
+}
+/** scope: end */

package/dist/.metadata/this.d.ts

@@ -0,0 +1,2 @@
+export declare const __ThisModule__ = "test-vona";
+export { ScopeModuleTestVona as ScopeModule } from './index.ts';

package/dist/.metadata/this.js

@@ -0,0 +1,2 @@
+export const __ThisModule__ = 'test-vona';
+export { ScopeModuleTestVona as ScopeModule } from "./index.js";

package/dist/bean/aop.regExp.d.ts

@@ -0,0 +1,7 @@
+import { BeanAopBase } from 'vona';
+export declare class AopRegExp extends BeanAopBase {
+    __get_name__(next: any): string;
+    __set_name__(value: any, next: any): any;
+    actionSync(_args: any, next: any): string;
+    actionAsync(_args: any, next: any): Promise<string>;
+}