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

@@ -26,14 +26,6 @@ const commands = {
     await (await import('./scripts/gen-insignificant')).default()
     console.log("\n✅ Milkio Insignificant Generated!")
   },
-  // async "build:cookbook"() {
-  //   await exec(rootPath, ["bun", "./node_modules/milkio/scripts/build-cookbook.ts"])
-  // },
-  // async "build:dto"() {
-  //   await exec(join(rootPath, "packages", "dto"), ["bun", "i"])
-  //   await exec(rootPath, ["bun", "./node_modules/milkio/scripts/generate.ts"])
-  //   await exec(rootPath, ["bun", "./node_modules/milkio/scripts/build-dto.ts"])
-  // },
   async EAR(commandBase64ed: string) {
     try { await $`clear` } catch (e) {}
     const command = Buffer.from(commandBase64ed, 'base64').toString('utf-8')

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.12",
+  "version": "0.0.14",
   "peerDependencies": {
     "typescript": "^5.4.2"
   },

package/scripts/gen-insignificant.ts

@@ -237,15 +237,15 @@ export default async () =>  {
   console.timeEnd(`🧊 Cookbook Stage`)
   console.log(``)
 
-  console.time(`🧊 DTO Stage`)
-  await $`bun run ./node_modules/typescript/bin/tsc --outDir "./packages/dto/project"`.quiet()
+  console.time(`🧊 Client Stage`)
+  await $`bun run ./node_modules/typescript/bin/tsc --outDir "./packages/client/project"`.quiet()
   await Bun.build({
-    entrypoints: ["./packages/dto/index.ts"],
-    outdir: "./packages/dto/dist",
+    entrypoints: ["./packages/client/index.ts"],
+    outdir: "./packages/client/dist",
     target: 'browser',
     minify: true
   })
-  console.timeEnd(`🧊 DTO Stage`)
+  console.timeEnd(`🧊 Client Stage`)
   console.log(``)
 
   if (!existsSync(join(cwd(), "milkio.toml"))) return

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">();
 

package/scripts-del/build-cookbook.ts

@@ -1,233 +0,0 @@
-/* eslint-disable no-console, @typescript-eslint/no-dynamic-delete */
-
-import { TSON, type Cookbook } from ".."
-import { join } from "node:path"
-import { cwd } from "node:process"
-import { writeFile, readFile } from "node:fs/promises"
-
-export async function buildCookbook() {
-  const schema = await import("../../../generated/api-schema")
-  const paths = Object.keys(schema.default.apiMethodsSchema)
-
-  const cookbook: Cookbook = {}
-  for (const path of paths) {
-    // const module = await import(/* @vite-ignore */ join(`../../../src/apps/${path}`));
-    const code = (await readFile(join(cwd(), `./src/apps/${path}.ts`))).toString()
-    const codeLines = code.split("\n")
-    let title
-    let desc
-    const descRaw = /\n\/\*\*\n[\s\S]+?\*\//.exec(code)?.[0] ?? ""
-
-    if (descRaw) {
-      const descRawLines = descRaw.split("\n")
-      if (descRawLines.at(0)?.trim() === "") descRawLines.shift()
-      if (descRawLines.at(-1)?.trim() === "") descRawLines.pop()
-      let first = true
-      for (let index = 0; index < descRawLines.length; index++) {
-        const descRawLine = descRawLines[index].replace(/^[/ ]+?[*]*/, "").replace(/[*]*\/$/, "")
-
-        if (!descRawLine) continue
-        if (first) {
-          title = descRawLine.replace(/#/g, "").trim()
-          // Originally the title was in the first line, desc is the rest of it, now desc contains complete markdown content.
-          // continue;
-        }
-        first = false
-        desc = (desc ?? "") + "\n" + descRawLine.trim()
-      }
-    }
-
-    let apiParams = /action\([\s\S]+?\)/.exec(code)?.[0] ?? "" // The intention of the following code is to extract the parameter part of the action.
-    apiParams = /\([\s\S]*,/.exec(apiParams)?.[0] ?? ""
-    apiParams = apiParams.slice(0, -1)
-    apiParams = apiParams.slice(/[\s\S]+?:/.exec(apiParams)?.[0].length)
-    const apiParamsLines = apiParams.split("\n") // The intention of the following code is to remove extra spaces, which will make the code look more beautiful.
-    if (apiParamsLines.at(-1)?.trim() === "") apiParamsLines.pop()
-    if (apiParamsLines.at(-1)?.trim() === "") apiParamsLines.pop()
-    let spaceNumber = 0
-    for (const char of apiParamsLines.at(-1) ?? "") {
-      if (char === " ") spaceNumber++
-      else break
-    }
-    for (let index = 0; index < apiParamsLines.length; index++) {
-      const line = apiParamsLines[index]
-      let spaceNumberForThisLine = 0
-      for (const char of line) {
-        if (char === " ") spaceNumberForThisLine++
-        else break
-      }
-      if (spaceNumberForThisLine >= spaceNumber) {
-        apiParamsLines[index] = line.slice(spaceNumber)
-      } else {
-        apiParamsLines[index] = line.slice(spaceNumberForThisLine)
-      }
-    }
-    apiParams = apiParamsLines.join("\n")
-
-    // Find the code for the API testing section.
-    const apiTestsCodeChars = []
-    let apiTestsStartIndex = undefined as undefined | number
-    let semicolonMatch = 0
-    let semicolonMax = 0
-    for (let index = 0; index < codeLines.length; index++) {
-      const codeLine = codeLines[index]
-      if (apiTestsStartIndex === undefined && !codeLine.includes("defineApiTest(")) continue
-      if (apiTestsStartIndex === undefined) apiTestsStartIndex = index
-      const codeChars = codeLine.split("")
-      for (const codeChar of codeChars) {
-        if (codeChar === "[") {
-          semicolonMatch++
-          semicolonMax++
-        }
-        if (semicolonMatch !== 0) apiTestsCodeChars.push(codeChar)
-        if (codeChar === "]") semicolonMatch--
-      }
-      if (semicolonMatch === 0 && semicolonMax >= 1) {
-        break
-      }
-      apiTestsCodeChars.push("\n")
-    }
-
-    // Find the code for each API test case.
-    const apiCaseCodes: Array<string> = []
-    let currentApiCaseCode = undefined as undefined | Array<string>
-    let apiTestCaseStartIndex = undefined as undefined | number
-    let apiTestCaseMatch = 0
-    for (let index = 0; index < apiTestsCodeChars.length; index++) {
-      const apiTestsCodeChar = apiTestsCodeChars[index]
-      if (apiTestCaseStartIndex === undefined && apiTestsCodeChar === "{") {
-        currentApiCaseCode = []
-        apiTestCaseStartIndex = index
-      }
-      if (apiTestsCodeChar === "{") {
-        apiTestCaseMatch++
-      }
-
-      if (apiTestCaseMatch !== 0) currentApiCaseCode!.push(apiTestsCodeChar)
-
-      if (apiTestsCodeChar === "}") {
-        apiTestCaseMatch--
-        if (apiTestCaseMatch === 0) {
-          apiCaseCodes.push(currentApiCaseCode!.join(""))
-          currentApiCaseCode = undefined
-          apiTestCaseStartIndex = undefined
-        }
-      }
-    }
-
-    const apiCases: Array<{
-      name: string;
-      handler: string;
-    }> = []
-
-    for (let index = 0; index < apiCaseCodes.length; index++) {
-      const code = apiCaseCodes[index]
-      const name = /name:[\s\S]+?,/.exec(code)?.[0]?.slice(5, -1)?.trim().slice(1, -1) ?? ""
-      const handlerChars = /handler:[\s\S]*/.exec(code)?.[0]?.split("") ?? []
-      let handler = "" // Find the main code of the handler.
-      let handlerStartIndex = undefined as undefined | number
-      let handlerMatch = 0
-      for (let index = 0; index < handlerChars.length; index++) {
-        const handlerChar = handlerChars[index]
-        if (handlerStartIndex !== undefined && handlerChar === "{") handlerStartIndex = index
-        if (handlerChar === "{") handlerMatch++
-        if (handlerMatch !== 0) handler = handler + handlerChar
-        if (handlerChar === "}") handlerMatch--
-        if (handlerStartIndex !== undefined && handlerMatch === 0) break
-      }
-      handler = handler.slice(1, -1)
-
-      const handlerLines = handler.split("\n") // The intention of the following code is to remove extra spaces, which will make the code look more beautiful.
-      if (handlerLines.at(-1)?.trim() === "") handlerLines.pop()
-      if (handlerLines.at(-1)?.trim() === "") handlerLines.pop()
-      if (handlerLines.at(0)?.trim() === "") handlerLines.shift()
-      if (handlerLines.at(0)?.trim() === "") handlerLines.shift()
-      let spaceNumber = 0
-      for (const char of handlerLines.at(-1) ?? "") {
-        if (char === " ") spaceNumber++
-        else break
-      }
-      for (let index = 0; index < handlerLines.length; index++) {
-        const line = handlerLines[index]
-        let spaceNumberForThisLine = 0
-        for (const char of line) {
-          if (char === " ") spaceNumberForThisLine++
-          else break
-        }
-        if (spaceNumberForThisLine >= spaceNumber) {
-          handlerLines[index] = line.slice(spaceNumber)
-        } else {
-          handlerLines[index] = line.slice(spaceNumberForThisLine)
-        }
-      }
-      handler = handlerLines.join("\n")
-
-      apiCases.push({
-        name,
-        handler
-      })
-    }
-
-    // This value has been deprecated because TypeScript types can already replace it well
-    // let paramsSchema;
-    // try {
-    //   const moduleGenerated = await import(/* @vite-ignore */ `../../../generated/products/apps/${path}`);
-    //   paramsSchema = moduleGenerated.paramsSchema.schemas[0]?.properties?.data;
-    // } catch (error) {}
-
-    cookbook[path] = {
-      title,
-      desc,
-      params: apiParams,
-      cases: apiCases
-    }
-  }
-
-  /**
-   * -- indexes
-   */
-
-  const indexes: Record<string, Array<string>> = {}
-  const folderIndexes: Record<string, Array<string>> = {}
-  indexes["(root)"] = []
-  folderIndexes["(root)"] = []
-  for (const path in cookbook) {
-    if (!path.includes("/")) indexes["(root)"].push(path)
-  }
-  for (const path in cookbook) {
-    const dirnames = path.split("/")
-    for (let index = 0; index < dirnames.length - 1; index++) {
-      const dirpath = dirnames.slice(0, index + 1).join("/")
-      if (!indexes[dirpath]) indexes[dirpath] = []
-      if (!folderIndexes[dirpath]) folderIndexes[dirpath] = []
-      if (index + 1 === dirnames.length - 1) {
-        indexes[dirpath].push(path)
-      } else {
-        const childDirpath = dirnames.slice(0, index + 2).join("/")
-        if (folderIndexes[dirpath].includes(childDirpath)) continue
-        folderIndexes[dirpath].push(childDirpath)
-      }
-    }
-  }
-  for (const path in folderIndexes) {
-    if (path.includes("/") || path === "(root)") continue
-    folderIndexes["(root)"].push(path)
-  }
-
-  const readme = (await readFile(join(cwd(), "src", "apps", "README.md"))).toString()
-  Object.keys(indexes).forEach((key) => indexes[key].length === 0 && delete indexes[key])
-  const generatedAt = new Date()
-
-  await writeFile(
-    join(cwd(), `./generated/cookbook.json`),
-    TSON.stringify({
-      cookbook,
-      readme,
-      indexes,
-      folderIndexes,
-      generatedAt
-    })
-  )
-}
-
-void buildCookbook()

package/scripts-del/build-dto.ts

@@ -1,65 +0,0 @@
-/* eslint-disable no-console */
-import { cwd, platform } from "node:process"
-import { exec as nodeExec } from "node:child_process"
-import { removeDir } from "../utils/remove-dir"
-import { join } from "node:path"
-import { copyFile, mkdir } from "node:fs/promises"
-
-export async function buildDTO() {
-  console.log("🥛 Milkio DTO Building..")
-
-  removeDir(join(cwd(), "packages", "dto", "dist"))
-  removeDir(join(cwd(), "packages", "dto", "generated"))
-  await mkdir(join(cwd(), "packages", "dto", "dist"))
-  await mkdir(join(cwd(), "packages", "dto", "generated"))
-
-  // Generate the corresponding types for the files in the project and output them to the /packages/dto/generate directory.
-  await new Promise((resolve) =>
-    nodeExec("bun ./node_modules/typescript/bin/tsc --project tsconfig.build-dto.json", (e, stdout) => {
-      resolve(e)
-    })
-  )
-  await copyFile(join(cwd(), "src", "fail-code.ts"), join(cwd(), "packages", "dto", "generated", "src", "fail-code.ts"))
-
-  // Packaging type for the dto
-  await new Promise((resolve) =>
-    nodeExec("cd ./packages/dto && bunx tsc", (e) => {
-      resolve(e)
-    })
-  )
-
-  // build /src/dto/index.ts to js
-  await Bun.build({
-    entrypoints: ["./packages/dto/index.ts"],
-    outdir: "./packages/dto"
-  })
-
-  const root = join(cwd(), "packages", "dto")
-
-  console.log("🥛 Milkio DTO Build Finished")
-  console.log("\x1B[2m")
-  console.log("Now, your latest code (including changes to your interface) is built to the latest version and waiting for your release!")
-  console.log("")
-  console.log("If you want to publish it to NPM, you can use a command similar to the following.")
-  console.log(`(But before that, you may need to modify the package name (${join(cwd(), "packages", "dto", "package.json")}) and login to your NPM account or private NPM repository)`)
-
-  if (platform !== "win32") {
-    console.log("You can publish it to npm by running this commands:\n")
-    console.log("\u001B[0m---")
-    console.log(`cd ${join(root)} \\`)
-    console.log("  && npm version major \\")
-    console.log("  && npm publish --access public \\")
-    console.log(`  && cd ${join(cwd())}`)
-  } else {
-    console.log("You can publish it to npm by running this commands (use \x1B[42mPowerShell\x1B[0m):")
-    console.log("\u001B[0m---")
-    console.log('$ErrorActionPreference = "Stop";')
-    console.log(`Set-Location ${join(root)};`)
-    console.log("npm version major;")
-    console.log("npm publish --access public;")
-    console.log(`Set-Location ${join(cwd())};`)
-  }
-  console.log("---")
-}
-
-await buildDTO()

package/scripts-del/generate/generate-app-partial.ts

@@ -1,74 +0,0 @@
-/* eslint-disable no-console */
-
-import ejs from "ejs"
-import { join } from "node:path"
-import { existsSync, mkdirSync } from "node:fs"
-import { cwd, env, exit } from "node:process"
-import { writeFile, readFile } from "node:fs/promises"
-import { exec as nodeExec } from "node:child_process"
-import { camel, hump, hyphen } from "@poech/camel-hump-under"
-
-const utils = {
-  camel: (str: string) => camel(str).replaceAll("-", "").replaceAll("_", ""),
-  hump: (str: string) => hump(str).replaceAll("-", "").replaceAll("_", ""),
-  hyphen: (str: string) => hyphen(str).replaceAll("_", "")
-}
-
-export async function generateAppPartial(path?: string) {
-  const partialPath = path ?? env.GENERATE_PARTIAL_PATH!
-  const partialDir = partialPath.split("/").slice(0, -1).join("/")
-  // Generate api-schema.ts file through templates
-  const templateVars = {
-    utils
-  }
-
-  if (!partialPath.endsWith(".ts")) return
-  const module = await import(/* @vite-ignore */ `../../../../src/apps/${partialPath}`)
-  if (module?.api?.isApi === true) {
-    // Exclude disallowed characters
-    if (partialPath.includes("_")) {
-      console.error(`\n\nPath: ` + partialPath)
-      console.error(`Do not use "_" in the path. If you want to add a separator between words, please use "-".\n`)
-      exit(1)
-    }
-    if (/^[a-z0-9/-]+$/.test(partialPath)) {
-      console.error(`\n\nPath: ` + partialPath)
-      console.error(`The path can only contain lowercase letters, numbers, and "-".\n`)
-      exit(1)
-    }
-  }
-
-  // typia
-  const filePathTmp = join(cwd(), "generated", "raw-tmp", "apps", partialPath)
-  const dirPathTmp = join(cwd(), "generated", "raw-tmp", "apps", partialPath).split("/").slice(0, -1).join("/")
-  const filePath = join(cwd(), "generated", "raw", "apps", partialPath)
-  if (!existsSync(dirPathTmp)) {
-    mkdirSync(dirPathTmp, { recursive: true })
-  }
-  let importPath = "../../../"
-
-  for (let i = 0; i < partialPath.split("/").length - 1; i++) {
-    importPath = importPath + "../"
-  }
-  importPath = importPath + "src/apps"
-  const template = `
-import typia from "typia";
-import { _validate, type ExecuteResultSuccess } from "milkio";
-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);
-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); };
-`.trim()
-
-  await writeFile(filePathTmp, ejs.render(template, { ...templateVars, path: partialPath }))
-
-  await new Promise((resolve) =>
-    nodeExec(`bun run ./node_modules/typia/lib/executable/typia.js generate --input generate/raw-tmp/apps/${partialDir} --output generate/products-tmp/apps/${partialDir} --project tsconfig.json`, (e) => {
-      resolve(e)
-    })
-  )
-  await Promise.all([writeFile(filePath, ejs.render(template, { ...templateVars, path: partialPath })), writeFile(join(cwd(), "generated", "products", "apps", partialPath), (await readFile(join(cwd(), "generated", "products-tmp", "apps", partialPath))).toString())])
-}

package/scripts-del/generate/generate-app.ts

@@ -1,152 +0,0 @@
-/* eslint-disable no-console */
-
-import ejs from "ejs"
-import { join } from "node:path"
-import { existsSync, mkdirSync } from "node:fs"
-import { cwd, exit } from "node:process"
-import { unlink, writeFile } from "node:fs/promises"
-import { exec as nodeExec } from "node:child_process"
-import { camel, hyphen } from "@poech/camel-hump-under"
-import { Glob } from "bun"
-
-const utils = {
-  camel: (str: string) => camel(str).replaceAll("-", "").replaceAll("_", ""),
-  hyphen: (str: string) => hyphen(str).replaceAll("_", "")
-}
-
-export async function generateApp() {
-  // Delete the files generated in the past and regenerate them
-  try {
-    await unlink(join(cwd(), "generated", "api-schema.ts"))
-  } catch (error) {} // Maybe the file does not exist
-
-  if (!existsSync(join("generated", "README.md"))) {
-    await writeFile(join("generated", "README.md"), "⚠️ All files in this directory are generated by milkio. Please do not modify the content, otherwise your modifications will be overwritten in the next generation.")
-  }
-
-  // Write a basic framework to ensure that there are no errors when reading later
-  const apiSchemaSkeleton = `
-  export default {
-    apiValidator: {},
-    apiMethodsSchema: {},
-    apiMethodsTypeSchema: {},
-  }
-  `
-  await writeFile(join(cwd(), "generated", "api-schema.ts"), ejs.render(apiSchemaSkeleton, { utils }))
-
-  // Generate api-schema.ts file through templates
-  const templateVars = {
-    utils,
-    apiPaths: [] as Array<string>,
-    apiTestPaths: [] as Array<string>
-  }
-
-  const glob = new Glob("**/*.ts")
-  const appFiles = await Array.fromAsync(glob.scan({ cwd: join(cwd(), "src", "apps") }))
-
-  for (const path of appFiles) {
-    if (!path.endsWith(".ts")) continue
-    const module = await import(/* @vite-ignore */ `../../../../src/apps/${path}`)
-    if (module?.api?.isApi === true) {
-      // Exclude disallowed characters
-      if (path.includes("_")) {
-        console.error(`\n\nPath: ` + `"${path}"`)
-        console.error(`Do not use "_" in the path. If you want to add a separator between words, please use "-".\n`)
-        exit(1)
-      }
-      if (!/^[a-z0-9/-]+$/.test(path.slice(0, -3))) {
-        console.error(`\n\nPath: ` + `"${path}"`)
-        console.error(`The path can only contain lowercase letters, numbers, and "-".\n`)
-        exit(1)
-      }
-
-      templateVars.apiPaths.push(path)
-
-      if (module?.test?.isApiTest === true) {
-        templateVars.apiTestPaths.push(path)
-      }
-
-      // typia
-      const filePath = join(cwd(), "generated", "raw", "apps", path)
-      const dirPath = join(cwd(), "generated", "raw", "apps", path).split("/").slice(0, -1).join("/")
-      if (!existsSync(dirPath)) {
-        mkdirSync(dirPath, { recursive: true })
-      }
-      let importPath = "../../../"
-
-      for (let i = 0; i < path.split("/").length - 1; i++) {
-        importPath = importPath + "../"
-      }
-      importPath = importPath + "src/apps"
-      const template = `
-import typia from "typia";
-import { _validate, type ExecuteResultSuccess } from "milkio";
-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);
-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); };
-
-`.trim()
-      // export const paramsSchema = typia.json.application<[{ data: ParamsT }], "swagger">();
-
-      await writeFile(filePath, ejs.render(template, { ...templateVars, path }))
-    }
-  }
-
-  await writeFile(
-    join(cwd(), "generated", "api-schema.ts"),
-    ejs.render(
-      `
-/**
- * ⚠️ This file is generated and modifications will be overwritten
- */
-
-// api
-<% for (const path of ${"apiPaths"}) { %>import type * as <%= utils.camel(path.slice(0, -3).replaceAll('/', '$')) %> from '${"../src/apps"}/<%= path.slice(0, -3) %>'
-<% } %>
-import _apiValidator from './products/api-validator.ts'
-
-export default {
-  apiValidator: _apiValidator,
-  ${"apiMethodsSchema"}: {
-    <% for (const path of apiPaths) { %>'<%= utils.hyphen(path.slice(0, -${3})) %>': () => ({ module: import('../src/apps/<%= path.slice(0, -${3}) %>') }),
-    <% } %>
-  },
-  ${"apiMethodsTypeSchema"}: {
-    <% for (const path of apiPaths) { %>'<%= utils.hyphen(path.slice(0, -${3})) %>': undefined as unknown as typeof <%= utils.camel(path.slice(0, -${3}).replaceAll('/', '$')) %>,
-    <% } %>
-  },
-  ${"apiTestsSchema"}: {
-    <% for (const path of apiTestPaths) { %>'<%= utils.hyphen(path.slice(0, -${3})) %>': () => ({ module: import('../src/apps/<%= path.slice(0, -${3}) %>') }),
-    <% } %>
-  },
-}
- `.trim(),
-      templateVars
-    )
-  )
-
-  // api
-  const apiValidatorTemplate = `/**
- * ⚠️This file is generated and modifications will be overwritten
- */
-
-export default {
-  generatedAt: ${new Date().getTime()},
-  ${"validate"}: {
-    <% for (const path of apiPaths) { %>'<%= utils.hyphen(path.slice(0, -${3})) %>': () => import('./apps/<%= utils.hyphen(path) %>'),
-    <% } %>
-  },
-}
-`.trim()
-  await writeFile(join(cwd(), "generated", "raw", "api-validator.ts"), ejs.render(apiValidatorTemplate, templateVars))
-
-  await new Promise((resolve) =>
-    nodeExec("bun run ./node_modules/typia/lib/executable/typia.js generate --input generate/raw --output generate/products --project tsconfig.json", (e) => {
-      resolve(e)
-    })
-  )
-}

package/scripts-del/generate/generate-database.ts

@@ -1,22 +0,0 @@
-/* eslint-disable no-console */
-
-import ejs from "ejs"
-import { join } from "node:path"
-import { existsSync } from "node:fs"
-import { cwd } from "node:process"
-import { writeFile } from "node:fs/promises"
-import { Glob } from "bun"
-
-export async function generateDatabase() {
-  if (existsSync(join(cwd(), "src", "databases"))) {
-    if (!existsSync(join("generated", "database-schema.ts"))) {
-      await writeFile(join("generated", "database-schema.ts"), ``)
-    }
-    const filePath = join(cwd(), "generated", "database-schema.ts")
-    const glob = new Glob("**/*.ts")
-    const databaseFiles = await Array.fromAsync(glob.scan({ cwd: join(cwd(), "src", "databases") }))
-    const template = `<% for (const path of ${"databaseFiles"}) { %>export * from '${"../src/databases"}/<%= path.slice(0, -3) %>'
-<% } %>`
-    await writeFile(filePath, ejs.render(template, { databaseFiles }))
-  }
-}

package/scripts-del/generate-partial.ts

@@ -1,15 +0,0 @@
-/* eslint-disable no-console, @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument */
-
-import { exit } from "node:process"
-import { generateApp } from "./generated/generate-app"
-console.log("Milkio Quick Generating..")
-
-export async function generatePartial() {
-  await generateApp()
-}
-
-await generatePartial()
-
-console.log("\n✅ Milkio Generated!")
-
-exit(0)

package/scripts-del/generate.ts

@@ -1,23 +0,0 @@
-/* eslint-disable no-console */
-
-import { join } from "node:path"
-import { existsSync, mkdirSync } from "node:fs"
-import { exit } from "node:process"
-import { generateApp } from "./generated/generate-app"
-
-export async function generate() {
-  // Make sure that the existing directories are all present
-  existsSync(join("generated")) || mkdirSync(join("generated"))
-  existsSync(join("generated", "raw")) || mkdirSync(join("generated", "raw"))
-  existsSync(join("generated", "raw", "apps")) || mkdirSync(join("generated", "raw", "apps"))
-
-  await generateApp()
-}
-
-console.log("Milkio Generating..")
-
-await generate()
-
-console.log("\n✅ Milkio Generated!")
-
-exit(0)