milkio 0.0.13 → 0.0.15

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/c.ts

@@ -29,6 +29,7 @@ const commands = {
   async EAR(commandBase64ed: string) {
     try { await $`clear` } catch (e) {}
     const command = Buffer.from(commandBase64ed, 'base64').toString('utf-8')
+    console.log('\x1B[2m%s\x1B[0m', `$ ${command}`)
     await $`${{ raw: command }}`
     process.on('SIGINT', () => {}) // prevent users from exiting by pressing ctrl + c
     while (true) await new Promise((resolve) => process.stdin.on('keypress', resolve))

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.15",
   "peerDependencies": {
     "typescript": "^5.4.2"
   },

package/scripts/gen-insignificant.ts

@@ -12,7 +12,7 @@ export default async () =>  {
   const paths = Object.keys(schema.default.apiMethodsSchema)
 
   console.log('')  
-  console.time(`🧊 Cookbook Stage`)
+  console.time(`🌟 Cookbook Stage`)
 
   const cookbook: Cookbook = {}
   for (const path of paths) {
@@ -234,10 +234,10 @@ export default async () =>  {
     })
   )
 
-  console.timeEnd(`🧊 Cookbook Stage`)
+  console.timeEnd(`🌟 Cookbook Stage`)
   console.log(``)
 
-  console.time(`🧊 Client Stage`)
+  console.time(`🌟 Client Stage`)
   await $`bun run ./node_modules/typescript/bin/tsc --outDir "./packages/client/project"`.quiet()
   await Bun.build({
     entrypoints: ["./packages/client/index.ts"],
@@ -245,7 +245,7 @@ export default async () =>  {
     target: 'browser',
     minify: true
   })
-  console.timeEnd(`🧊 Client Stage`)
+  console.timeEnd(`🌟 Client Stage`)
   console.log(``)
 
   if (!existsSync(join(cwd(), "milkio.toml"))) return
@@ -254,8 +254,8 @@ export default async () =>  {
   let i = 0
   for (const command of milkioConfig.generate.significant) {
     ++i
-    console.time(`🧊 Insignificant Stage (LINE ${i})`)
+    console.time(`🌟 Insignificant Stage (LINE ${i})`)
     await $`${{ raw: command }}`
-    console.timeEnd(`🧊 Insignificant Stage (LINE ${i})`)
+    console.timeEnd(`🌟 Insignificant Stage (LINE ${i})`)
   }
 }

package/scripts/gen-significant.ts

@@ -50,7 +50,7 @@ export default async () => {
   const appFiles = await Array.fromAsync(glob.scan({ cwd: join(cwd(), "src", "apps") }))
 
 
-  console.time(`🧊 File Stage`)
+  console.time(`🌟 File Stage`)
   
 
   for (const path of appFiles) {
@@ -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">();
 
@@ -154,13 +154,13 @@ export default {
 `.trim()
   await writeFile(join(cwd(), "generated", "raw", "api-validator.ts"), ejs.render(apiValidatorTemplate, templateVars))
   
-  console.timeEnd(`🧊 File Stage`)
+  console.timeEnd(`🌟 File Stage`)
   console.log(``)
 
   // typia
-  console.time(`🧊 Typia Stage`)
+  console.time(`🌟 Typia Stage`)
   await $`bun run ./node_modules/typia/lib/executable/typia.js generate --input generated/raw --output generated/products --project tsconfig.json`
-  console.timeEnd(`🧊 Typia Stage`)
+  console.timeEnd(`🌟 Typia Stage`)
   console.log(``)
 
   if (!existsSync(join(cwd(), "milkio.toml"))) return
@@ -169,8 +169,8 @@ export default {
   let i = 0
   for (const command of milkioConfig.generate.significant) {
     ++i
-    console.time(`🧊 Significant Stage (LINE ${i})`)
+    console.time(`🌟 Significant Stage (LINE ${i})`)
     await $`${{ raw: command }}`
-    console.timeEnd(`🧊 Significant Stage (LINE ${i})`)
+    console.timeEnd(`🌟 Significant Stage (LINE ${i})`)
   }
 }

package/templates/api.ts

@@ -5,45 +5,41 @@ await createTemplate(async (tools) => {
   return {
     path: join(tools.directory, `${tools.hyphen(tools.name)}.ts`),
     content: `
-import { defineApi, defineApiTest } from "milkio";
+import { defineApi, defineApiTest } from "milkio"
 
 /**
- * ${tools.hyphen(tools.name)}
+ * ${tools.name} ${tools.src()}
  */
 export const api = defineApi({
   meta: {
-    //
+    // your meta..
   },
   async action(
     params: {
-      //
+      // your params..
     },
     context
   ) {
-    const message = \`hello world!\`;
+    const message = \`hello world!\`
 
-    // ..
+    // your code..
 
     return {
       say: message
-    };
+    }
   }
-});
+})
 
 export const test = defineApiTest(api, [
   {
     name: "Basic",
     handler: async (test) => {
-      const result = await test.execute({
-        //
-      });
-
-      // ..
+      const result = await test.execute(await test.randParams())
 
-      if (!result.success) return test.reject(\`The result was not success\`);
+      if (!result.success) return test.reject(\`The result was not success\`)
     }
   }
-]);    
+])
 `.trim()
   }
 })

package/utils/create-template.ts

@@ -4,6 +4,7 @@ import { camel, hump, hyphen } from "@poech/camel-hump-under"
 export type CreateTemplateTools = {
   name: string;
   directory: string;
+  src: () => string;
   camel: (str: string) => string;
   hump: (str: string) => string;
   hyphen: (str: string) => string;
@@ -23,6 +24,15 @@ export async function createTemplate(fn: CreateTemplateFn) {
   const tools = {
     name: argv[2],
     directory: argv[3],
+    src: () => {
+      const patharr = argv[3].split("/")
+      const i = patharr.length - patharr.findIndex((str: string) => str.startsWith("src")) - 1
+      let path = ''
+      for (let j = 0; j < i; j++) {
+        path += "../"
+      }
+      return path
+    },
     camel: (str: string) => camel(str).replaceAll("-", "").replaceAll("_", ""),
     hump: (str: string) => hump(str).replaceAll("-", "").replaceAll("_", ""),
     hyphen: (str: string) => hyphen(str).replaceAll("_", "")