@_tc/template-core 0.0.1-bate.31 → 0.0.1-bate.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@_tc/template-core",
-  "version": "0.0.1-bate.31",
+  "version": "0.0.1-bate.32",
   "description": "A TypeScript Koa framework template - Monorepo root",
   "main": "./index.js",
   "types": "./index.d.ts",
@@ -8,19 +8,24 @@
     ".": {
       "import": "./esm/index.js",
       "require": "./cjs/index.js",
-      "types": "./esm/index.d.js"
+      "types": "./types/index.d.js"
     },
     "./bundler": {
       "import": "./esm/bundler/index.js",
       "require": "./cjs/bundler/index.js",
-      "types": "./esm/bundler/index.d.js"
+      "types": "./types/bundler/index.d.js"
     },
-    "./c/r": {
+    "./fe/main": {
+      "import": "./fe/frontend/main.js",
+      "require": "./fe/frontend/main.js",
+      "types": "./fe/frontend/main.d.js"
+    },
+    "./fe/rc": {
       "import": "./fe/packages/ui/react/index.js",
       "require": "./fe/packages/ui/react/index.js",
       "types": "./fe/packages/ui/react/index.d.js"
     },
-    "./c/r/*": {
+    "./fe/rc/*": {
       "import": "./fe/packages/ui/react/*",
       "require": "./fe/packages/ui/react/*",
       "types": "./fe/packages/ui/react/*"

package/types/app/controller/base.d.ts

@@ -0,0 +1,12 @@
+import type { KoaApp, Ctx } from "../type";
+declare const _default: (app: KoaApp) => {
+    new (): {
+        readonly app: KoaApp;
+        readonly config: KoaApp["config"];
+        get service(): import("../../packages/core").FrameworkAugment.IServiceAugmented;
+        success(ctx: Ctx, data: unknown): void;
+        fail(ctx: Ctx, code: number, message: string): void;
+        sendData(ctx: Ctx, data?: unknown, code?: number, message?: string | null, status?: number): void;
+    };
+};
+export default _default;

package/types/app/controller/project.d.ts

@@ -0,0 +1,10 @@
+import type { KoaApp, Ctx } from "../type";
+export interface IProjectController {
+    getModelList(ctx: Ctx): Promise<void>;
+    getProjectList(ctx: Ctx): Promise<void>;
+    getProject(ctx: Ctx): Promise<void>;
+    success(ctx: Ctx, data: unknown): void;
+    fail(ctx: Ctx, code: number, message: string): void;
+}
+declare const getProjectController: (app: KoaApp) => new () => IProjectController;
+export default getProjectController;

package/types/app/controller/view.d.ts

@@ -0,0 +1,7 @@
+import type { KoaApp, Ctx } from "../type";
+declare const getViewController: (app: KoaApp) => {
+    new (): {
+        renderPage(ctx: Ctx): Promise<void>;
+    };
+};
+export default getViewController;

package/types/app/data/signKey.d.ts

@@ -0,0 +1 @@
+export declare const signKey = "sakjdfnkjwjfnfkjkjldljksndf";

package/types/app/extend/db.d.ts

@@ -0,0 +1,2 @@
+import type { KoaApp } from "../type";
+export default function getDB(app: KoaApp): Promise<{}>;

package/types/app/extend/generateErrorMessage.d.ts

@@ -0,0 +1,7 @@
+interface ErrorOption {
+    status?: number;
+    code?: string | number;
+    showError?: boolean;
+}
+declare const _default: () => (message: string, option?: ErrorOption) => never;
+export default _default;

package/types/app/extend/logger.d.ts

@@ -0,0 +1,11 @@
+import type { KoaApp } from "../type";
+interface MConsole {
+    log: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    debug: (...args: any[]) => void;
+    trace: (...args: any[]) => void;
+}
+declare const _default: (app: KoaApp) => Promise<MConsole>;
+export default _default;

package/types/app/extend/parsingParamsOnUrl.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => (urlRules: string, url: string) => Record<string, string> | null;
+export default _default;

package/types/app/extend/render-view.d.ts

@@ -0,0 +1,3 @@
+import type { Ctx, KoaApp } from "../type";
+declare const _default: (app: KoaApp) => (view: string, ctx: Ctx, context?: Record<string, unknown>) => void;
+export default _default;

package/types/app/middleware/api-params-verify.d.ts

@@ -0,0 +1,4 @@
+import type Koa from "koa";
+import type { KoaApp, Ctx } from "../type";
+declare const _default: (app: KoaApp) => (ctx: Ctx, next: Koa.Next) => Promise<any>;
+export default _default;

package/types/app/middleware/api-sign-verify.d.ts

@@ -0,0 +1,4 @@
+import type Koa from "koa";
+import type { Ctx, KoaApp } from "../type";
+declare const _default: (app: KoaApp) => (ctx: Ctx, next: Koa.Next) => Promise<void>;
+export default _default;

package/types/app/middleware/error-handle.d.ts

@@ -0,0 +1,4 @@
+import type { Ctx, KoaApp } from "../type";
+import type Koa from "koa";
+declare const _default: (app: KoaApp) => (ctx: Ctx, next: Koa.Next) => Promise<void>;
+export default _default;

package/types/app/middleware/project-handler.d.ts

@@ -0,0 +1,4 @@
+import type { Ctx } from "../type";
+import type Koa from "koa";
+declare const _default: () => (ctx: Ctx, next: Koa.Next) => Promise<void>;
+export default _default;

package/types/app/middleware.d.ts

@@ -0,0 +1,3 @@
+import type { KoaApp } from "./typings";
+declare const _default: (app: KoaApp) => void;
+export default _default;

package/types/app/router/project.d.ts

@@ -0,0 +1,4 @@
+import type { KoaApp } from "../type";
+import type Router from "koa-router";
+declare const _default: (app: KoaApp, router: Router) => void;
+export default _default;

package/types/app/router/view.d.ts

@@ -0,0 +1,4 @@
+import type { KoaApp } from "../type";
+import type Router from "koa-router";
+declare const _default: (app: KoaApp, router: Router) => void;
+export default _default;

package/types/app/router-schema/project.d.ts

@@ -0,0 +1,3 @@
+import type { RouterSchemaType } from "./types";
+declare const routerSchema: RouterSchemaType;
+export default routerSchema;

package/types/app/service/bese.d.ts

@@ -0,0 +1,10 @@
+import type { KoaApp } from "../type";
+import superagent from "superagent";
+declare const _default: (app: KoaApp) => {
+    new (): {
+        get app(): KoaApp;
+        get config(): KoaApp["config"];
+        get curl(): superagent.SuperAgentStatic<superagent.Request>;
+    };
+};
+export default _default;

package/types/app/service/project.d.ts

@@ -0,0 +1,27 @@
+import type { KoaApp } from "../type";
+export interface ProjectItem {
+    key: string;
+    name: string;
+    desc: string;
+    homePage: string;
+    modelKey?: string;
+}
+export interface ModelItem {
+    model: {
+        key: string;
+        name: string;
+        desc: string;
+    };
+    project: Record<string, ProjectItem>;
+}
+declare const getProjectService: (app: KoaApp) => {
+    new (): {
+        getModelList(): Promise<ModelItem[]>;
+        getList: (key?: string) => ProjectItem[];
+        getProject: (projectKey: string) => ProjectItem | null;
+        get app(): KoaApp;
+        get config(): KoaApp["config"];
+        get curl(): import("superagent/lib/node").SuperAgentStatic<import("superagent/lib/node").Request>;
+    };
+};
+export default getProjectService;

package/types/app/type.d.ts

@@ -0,0 +1,2 @@
+export type KoaApp = import("./typings").KoaApp;
+export type Ctx = KoaApp["context"];

package/types/app/typings.d.ts

@@ -0,0 +1,50 @@
+import type { FrameworkAugment, KoaApp, KoaAppExtensions } from "../packages/core";
+import type getProjectService from "./service/project";
+import type getProjectController from "./controller/project";
+import type getViewController from "./controller/view";
+import type getDB from "./extend/db";
+import type getLogger from "./extend/logger";
+import type generateErrorMessage from "./extend/generateErrorMessage";
+import type parsingParamsOnUrl from "./extend/parsingParamsOnUrl";
+import renderView from "./extend/render-view";
+type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
+type GetInstance<T extends (...args: never[]) => unknown> = T extends (...args: never[]) => infer R ? R extends new () => infer C ? C : R extends Promise<infer P> ? P extends new () => infer C2 ? C2 : never : never : never;
+declare module "@tc/core" {
+    namespace FrameworkAugment {
+        interface IServiceAugmented {
+            project: GetInstance<typeof getProjectService>;
+        }
+        interface IControllerAugmented {
+            project: GetInstance<typeof getProjectController>;
+            view: GetInstance<typeof getViewController>;
+        }
+        interface IExtendsAugmented {
+            db: UnwrapPromise<ReturnType<typeof getDB>>;
+            logger: UnwrapPromise<ReturnType<typeof getLogger>>;
+            generateErrorMessage: ReturnType<typeof generateErrorMessage>;
+            parsingParamsOnUrl: ReturnType<typeof parsingParamsOnUrl>;
+            nunjucksEnv: import("nunjucks").Environment;
+            renderView: ReturnType<typeof renderView>;
+        }
+        interface IMiddlewaresAugmented {
+            errorHandle: import("koa").Middleware;
+            apiSignVerify: import("koa").Middleware;
+            apiParamsVerify: import("koa").Middleware;
+            projectHandler: import("koa").Middleware;
+        }
+        interface AppConfigAugmented {
+            frameName: string;
+            port?: number;
+            host?: string;
+            env?: string;
+            apiSignVerify?: {
+                whiteList?: string[];
+            };
+            viewsPath?: string;
+            nunjucks?: import("nunjucks").ConfigureOptions;
+        }
+    }
+}
+export type { FrameworkAugment };
+export { KoaAppExtensions };
+export type { KoaApp };

package/types/bundler/dev.d.ts

@@ -0,0 +1 @@
+export declare function dev(): Promise<void>;

package/types/bundler/index.d.ts

@@ -0,0 +1 @@
+export declare const buildFE: (mode: "dev" | "prod") => void;

package/types/bundler/prod.d.ts

@@ -0,0 +1 @@
+export declare function prod(): Promise<void>;

package/types/bundler/utils.d.ts

@@ -0,0 +1,4 @@
+export declare function entries(): Record<string, string>;
+export declare function outDir(): string;
+export declare const watchFiles: (callback?: () => Promise<any>) => Promise<void>;
+export declare const VBuildFE: (input: Record<string, string>) => Promise<void>;

package/types/index.d.ts

@@ -0,0 +1,28 @@
+import { StartOptions } from "./packages/core";
+import "./app/typings";
+import { MOmit } from "./typings/type";
+export type { Ctx } from "./app/type";
+export type { KoaApp, FrameworkAugment } from "./packages/core";
+import type Router from "koa-router";
+export type { Router };
+export declare const serverStart: (options?: MOmit<StartOptions, "frameBaseDir">) => import("./packages/core").KoaApp;
+export declare const baseFn: {
+    baseControllerFn: (app: import("./app/type").KoaApp) => {
+        new (): {
+            readonly app: import("./app/type").KoaApp;
+            readonly config: import("./app/type").KoaApp["config"];
+            get service(): import("./packages/core").FrameworkAugment.IServiceAugmented;
+            success(ctx: import(".").Ctx, data: unknown): void;
+            fail(ctx: import(".").Ctx, code: number, message: string): void;
+            sendData(ctx: import(".").Ctx, data?: unknown, code?: number, message?: string | null, status?: number): void;
+        };
+    };
+    baseServiceFn: (app: import("./app/type").KoaApp) => {
+        new (): {
+            get app(): import("./app/type").KoaApp;
+            get config(): import("./app/type").KoaApp["config"];
+            get curl(): import("superagent/lib/node").SuperAgentStatic<import("superagent/lib/node").Request>;
+        };
+    };
+};
+export { default as modelLoader } from "./packages/core/loader/model";

package/types/packages/core/env.d.ts

@@ -0,0 +1,15 @@
+export type EnvType = {
+    local: 'local' | string;
+    bate: 'bate' | string;
+    prod: 'prod' | string;
+};
+export type EnvKeys = keyof EnvType;
+export interface EnvReturn {
+    isLocal(): boolean;
+    isBate(): boolean;
+    isProd(): boolean;
+    get(): EnvType[keyof EnvType];
+    getEnvKeys(): EnvType;
+}
+declare const _default: () => EnvReturn;
+export default _default;

package/types/packages/core/index.d.ts

@@ -0,0 +1,6 @@
+import "./types";
+import "../../app/typings";
+import type { KoaApp, StartOptions } from "./types";
+export declare const loaderModel: (app: KoaApp) => import("./loader/model").ModelConfig;
+export type { AppConfig, AppOptions, StartOptions, KoaMiddleware, ProcessingFileCallbackFN, IService, IController, IExtends, IMiddlewares, KoaApp, KoaAppExtensions, FrameworkAugment, } from "./types";
+export declare const start: (options?: StartOptions) => KoaApp;

package/types/packages/core/loader/config.d.ts

@@ -0,0 +1,3 @@
+import type { KoaApp } from "../types";
+declare const _default: (app: KoaApp) => void;
+export default _default;

package/types/packages/core/loader/controller.d.ts

@@ -0,0 +1,3 @@
+import type { KoaApp } from "../types";
+declare const _default: (app: KoaApp) => void;
+export default _default;

package/types/packages/core/loader/extend.d.ts

@@ -0,0 +1,3 @@
+import type { KoaApp } from "../types";
+declare const _default: (app: KoaApp) => void;
+export default _default;

package/types/packages/core/loader/middleware.d.ts

@@ -0,0 +1,3 @@
+import type { KoaApp } from "../types";
+declare const _default: (app: KoaApp) => void;
+export default _default;

package/types/packages/core/loader/model.d.ts

@@ -0,0 +1,14 @@
+import { KoaApp } from "../types";
+export interface ModelItem {
+    model: {
+        key: string;
+        [k: string]: any;
+    };
+    project: {
+        key: string;
+        [k: string]: any;
+    };
+}
+export type ModelConfig = ModelItem[];
+declare const modelLoader: (app: KoaApp) => ModelConfig;
+export default modelLoader;

package/types/packages/core/loader/router-schema.d.ts

@@ -0,0 +1,3 @@
+import { KoaApp } from "../types";
+declare const _default: (app: KoaApp) => void;
+export default _default;

package/types/packages/core/loader/router.d.ts

@@ -0,0 +1,3 @@
+import { KoaApp } from "../types";
+declare const _default: (app: KoaApp) => void;
+export default _default;

package/types/packages/core/loader/service.d.ts

@@ -0,0 +1,3 @@
+import type { KoaApp } from "../types";
+declare const _default: (app: KoaApp) => void;
+export default _default;

package/types/packages/core/paths.d.ts

@@ -0,0 +1,11 @@
+export type AppPathType = "frame" | "business";
+export interface AppPathInfo {
+    type: AppPathType;
+    path: string;
+}
+export declare function getAppPath(app: {
+    paths?: AppPathInfo[];
+}, type: AppPathType): string | undefined;
+export declare function getAppPaths(app: {
+    paths?: AppPathInfo[];
+}): string[];

package/types/packages/core/types.d.ts

@@ -0,0 +1,73 @@
+import Koa from "koa";
+import type Router from "koa-router";
+import type { EnvReturn } from "./env";
+import type { AppPathInfo } from "./paths";
+export interface IService {
+    [key: string]: unknown;
+}
+export interface IController {
+    [key: string]: unknown;
+}
+export interface IExtends {
+    [key: string]: unknown;
+}
+export interface IMiddlewares {
+    [key: string]: unknown;
+}
+export declare namespace FrameworkAugment {
+    interface IServiceAugmented {
+    }
+    interface IControllerAugmented {
+    }
+    interface IExtendsAugmented {
+    }
+    interface IMiddlewaresAugmented {
+    }
+    interface AppConfigAugmented {
+    }
+}
+export type ICTX = Parameters<Router.IMiddleware<any, {}>>[0];
+export interface KoaAppExtensions {
+    baseDir: string;
+    frameBaseDir: string;
+    businessPath: string;
+    paths: AppPathInfo[];
+    framePath: string;
+    envs: EnvReturn;
+    config: FrameworkAugment.AppConfigAugmented;
+    extends: FrameworkAugment.IExtendsAugmented;
+    controller: FrameworkAugment.IControllerAugmented;
+    service: FrameworkAugment.IServiceAugmented;
+    middlewares: FrameworkAugment.IMiddlewaresAugmented;
+    model: unknown[];
+    routerSchema: Record<string, unknown>;
+    currentUseRouter: Router;
+    options: AppOptions;
+    logger?: {
+        info: (...args: unknown[]) => void;
+        error: (...args: unknown[]) => void;
+        warn: (...args: unknown[]) => void;
+    };
+    [key: string]: unknown;
+}
+export interface AppConfigBase {
+    port?: number;
+    host?: string;
+    env?: string;
+}
+export interface AppConfig extends AppConfigBase {
+    [key: string]: unknown;
+}
+export interface StartOptions {
+    name?: string;
+    homePage?: string;
+    frameBaseDir?: string;
+}
+export interface AppOptions extends StartOptions {
+    overwriteOriginalLogs?: boolean;
+    [key: string]: unknown;
+}
+export type KoaApp = Koa & KoaAppExtensions;
+export type KoaMiddleware = Koa.Middleware;
+export type { EnvType, EnvKeys } from "./env";
+export type ProcessingFileCallbackFN = <T extends Record<string, unknown>>(fileName: string, filePath: string, isDir: boolean, tempData: T) => T | undefined;

package/types/packages/utils/getAllFilesInFolder.d.ts

@@ -0,0 +1,4 @@
+export interface GetAllFilesInFolder {
+    getAllFilesInFolder(...paths: string[]): string[];
+}
+export declare const getAllFilesInFolder: (...paths: string[]) => string[];

package/types/packages/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./path";
+export * from "./loadFile";
+export * from "./getAllFilesInFolder";
+export * from "./runFileFn";

package/types/packages/utils/loadFile.d.ts

@@ -0,0 +1,14 @@
+export type PreProcessingFileCallbackFN = <T extends Record<string, any>>(filePath: string, result: T) => any;
+export type ProcessingFileCallbackFN = <T extends Record<string, any>>(fileName: string, filePath: string, isDir: boolean, tempData: T) => T | undefined;
+export type LoadFileCallbackFN = (filePath: string) => any;
+export interface LoadFileCallbackOptions {
+    loadFileCallback?: LoadFileCallbackFN;
+    processingFileCallback?: ProcessingFileCallbackFN;
+    preProcessingFileCallback?: PreProcessingFileCallbackFN;
+}
+declare function loadFileFn<T extends Record<string, unknown>>(baseDir: string, key: string, callbackOpt?: LoadFileCallbackOptions): T;
+export { loadFileFn };
+declare const _default: {
+    loadFileFn: typeof loadFileFn;
+};
+export default _default;

package/types/packages/utils/path.d.ts

@@ -0,0 +1,6 @@
+export interface SplicingOptions {
+    symbol?: string;
+    position?: "after" | "before";
+}
+export declare function splicing(str: string, opt?: SplicingOptions): string;
+export declare function resolve(...paths: string[]): string;

package/types/packages/utils/runFileFn.d.ts

@@ -0,0 +1,5 @@
+type AnyFun = (...p: any[]) => any;
+export declare const runFileFn: (fn: {
+    default: AnyFun;
+} | AnyFun) => AnyFun;
+export {};

package/types/typings/type.d.ts

@@ -0,0 +1,4 @@
+export type MOmit<T, K extends keyof T> = Omit<T, K>;
+export type UnionToTuple<T> = [
+    T
+] extends [never] ? [] : ((t: T) => T) extends ((t: infer U) => infer U) ? [...UnionToTuple<Exclude<T, U>>, U] : never;