milkio 0.0.13 → 0.0.14

package/api-test/index.ts

@@ -1,11 +1,12 @@
 /* eslint-disable no-constant-condition, @typescript-eslint/no-unsafe-argument, no-console, @typescript-eslint/no-explicit-any */
 
 import schema from "../../../generated/api-schema"
-import { type MilkioApp } from ".."
+import { useLogger, type MilkioApp } from ".."
 
 export const executeApiTests = async <Path extends Array<keyof (typeof schema)["apiTestsSchema"]>>(app: MilkioApp, path: Path | string | true | 1 | undefined) => {
   console.log(`🥛 Milkio Api Testing..\n`)
   
+  const logger = useLogger('global')
   let pathArr = [] as Array<string>
   if (!path || path === "1" || path === 1 || path === true) {
     pathArr = Object.keys(schema.apiTestsSchema) as unknown as Path
@@ -37,9 +38,12 @@ export const executeApiTests = async <Path extends Array<keyof (typeof schema)["
             throw new Error("")
           }, cs.timeout ?? 8192)
           await cs.handler({
+            log: (...args: Array<unknown>) => console.log(...args),
             // @ts-ignore
             execute: async (params: any, headers?: any, options?: any) => app.execute(path, params, headers ?? {}, options),
             executeOther: async (path: any, params: any, headers?: any, options?: any) => app.execute(path, params, headers ?? {}, options),
+            randParams: () => app.randParams(path as any),
+            randOtherParams: (path: any) => app.randParams(path),
             reject: (message?: string) => {
               console.error(`------`)
               console.error(`❌ REJECT -- ${message ?? "Test not satisfied"}`)

package/defines/define-api-test.ts

@@ -1,3 +1,4 @@
+import { Logger } from ".."
 import { type Api, type ExecuteResult, type ExecuteOptions } from ".."
 import type schema from "../../../generated/api-schema"
 
@@ -10,11 +11,11 @@ export function defineApiTest<ApiT extends Api>(_api: ApiT, cases: Array<ApiTest
 
 export type ApiTestCases<ApiT extends Api> = {
   handler: (test: {
-    // execute
+    log: (...params: Array<unknown>) => void;
     execute: (params: Parameters<ApiT["action"]>[0], headers?: Record<string, string>, options?: ExecuteOptions) => Promise<ExecuteResult<Awaited<ReturnType<ApiT["action"]>>>>;
-    // execute other
     executeOther: <Path extends keyof (typeof schema)["apiMethodsTypeSchema"], Result extends Awaited<ReturnType<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>>>(path: Path, params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string, headers?: Record<string, string>, options?: ExecuteOptions) => Promise<ExecuteResult<Result>>;
-    // reject
+    randParams: () => Promise<Parameters<ApiT["action"]>[0]>;
+    randOtherParams: <Path extends keyof (typeof schema)["apiMethodsTypeSchema"]>(path: Path) => Promise<Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]['api']['action']>[0]>;
     reject: (message?: string) => void;
   }) => Promise<void> | void;
   name: string;

package/kernel/milkio.ts

@@ -43,7 +43,8 @@ export async function createMilkioApp(MilkioAppOptions: MilkioAppOptions = {}) {
     execute: _execute,
     executeToJson: _executeToJson,
     _executeCore,
-    _executeCoreToJson
+    _executeCoreToJson,
+    randParams: _randParams
   }
 
   if (MilkioAppOptions.bootstraps) {
@@ -163,7 +164,7 @@ async function _executeCore<Path extends keyof (typeof schema)["apiMethodsTypeSc
     // check type
     // @ts-ignore
     // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-    _validate(await (await schema.apiValidator.validate[path]()).params(params))
+    params = _validate(await (await schema.apiValidator.validate[path]()).validateParams(params))
 
     // execute api
     let api: any
@@ -197,16 +198,21 @@ async function _executeCore<Path extends keyof (typeof schema)["apiMethodsTypeSc
 
 async function _executeToJson<Path extends keyof (typeof schema)["apiMethodsTypeSchema"]>(path: Path, params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string, headersInit: Record<string, string> | Headers = {}, options?: ExecuteOptions): Promise<string> {
   const resultsRaw = await _execute(path, params, headersInit, options)
-  const results = await (await schema.apiValidator.validate[path]()).results(TSON.encode(resultsRaw))
+  const results = await (await schema.apiValidator.validate[path]()).validateResults(TSON.encode(resultsRaw))
   return results
 }
 
 async function _executeCoreToJson<Path extends keyof (typeof schema)["apiMethodsTypeSchema"]>(path: Path, params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string, headersInit: Record<string, string> | Headers = {}, options: ExecuteCoreOptions): Promise<string> {
   const resultsRaw = await _executeCore(path, params, headersInit, options)
-  const results = await (await schema.apiValidator.validate[path]()).results(TSON.encode(resultsRaw))
+  const results = await (await schema.apiValidator.validate[path]()).validateResults(TSON.encode(resultsRaw))
   return results
 }
 
+
+export async function _randParams<Path extends keyof (typeof schema)["apiMethodsTypeSchema"]>(path: Path): Promise<Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]['api']['action']>[0]> {
+  return await (await schema.apiValidator.validate[path]()).randParams()
+}
+
 const apis = new Map<string, any>()
 
 export type ExecuteResult<Result> = ExecuteResultSuccess<Result> | ExecuteResultFail;
@@ -244,4 +250,4 @@ export type ExecuteCoreOptions = Mixin<
     logger: Logger;
     onAfterHeaders?: (headers: Headers) => void | Promise<void>;
   }
->;
+>;

package/kernel/validate.ts

@@ -1,8 +1,10 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
 import type { IValidation } from "typia"
 import { reject } from "../kernel/fail"
 
-export function _validate(validator: IValidation.IFailure | IValidation.ISuccess): void {
-  if (validator.success) return
+export function _validate(validator: IValidation.IFailure | IValidation.ISuccess): any {
+  if (validator.success) return validator.data
   const error = validator.errors[0]
 
   throw reject("TYPE_SAFE_ERROR", {

package/package.json

@@ -2,7 +2,7 @@
   "name": "milkio",
   "type": "module",
   "module": "index.ts",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "peerDependencies": {
     "typescript": "^5.4.2"
   },

package/scripts/gen-significant.ts

@@ -95,10 +95,10 @@ import { type TSONEncode } from "@southern-aurora/tson";
 import type * as <%= utils.camel(path.slice(0, -3).replaceAll('/', '$')) %> from '${importPath}/<%= path.slice(0, -3) %>';
 
 type ParamsT = Parameters<typeof <%= utils.camel(path.replaceAll('/', '$').slice(0, -${3})) %>['api']['action']>[0];
-export const params = async (params: any) => typia.misc.validatePrune<ParamsT>(params);
+export const validateParams = async (params: any) => typia.misc.validatePrune<ParamsT>(params);
 type ResultsT = Awaited<ReturnType<typeof <%= utils.camel(path.replaceAll('/', '$').slice(0, -${3})) %>['api']['action']>>;
-export const results = async (results: any) => { _validate(typia.validate<TSONEncode<ExecuteResultSuccess<ResultsT>>>(results)); return typia.json.stringify<TSONEncode<ExecuteResultSuccess<ResultsT>>>(results); };
-
+export const validateResults = async (results: any) => { _validate(typia.validate<TSONEncode<ExecuteResultSuccess<ResultsT>>>(results)); return typia.json.stringify<TSONEncode<ExecuteResultSuccess<ResultsT>>>(results); };
+export const randParams = async () => typia.random<ParamsT>();
 `.trim()
       // export const paramsSchema = typia.json.application<[{ data: ParamsT }], "swagger">();