milkio 0.0.10 → 0.0.12

package/scripts/gen-insignificant.ts

@@ -0,0 +1,261 @@
+/* eslint-disable no-console, @typescript-eslint/no-dynamic-delete */
+
+import { $ } from "bun"
+import { join } from "node:path"
+import { cwd } from "node:process"
+import { existsSync } from "node:fs"
+import { writeFile, readFile, mkdir, copyFile } from "node:fs/promises"
+import { MilkioConfig, TSON, type Cookbook } from ".."
+
+export default async () =>  {
+  const schema = await import("../../../generated/api-schema")
+  const paths = Object.keys(schema.default.apiMethodsSchema)
+
+  console.log('')  
+  console.time(`🧊 Cookbook Stage`)
+
+  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
+    })
+  )
+
+  console.timeEnd(`🧊 Cookbook Stage`)
+  console.log(``)
+
+  console.time(`🧊 DTO Stage`)
+  await $`bun run ./node_modules/typescript/bin/tsc --outDir "./packages/dto/project"`.quiet()
+  await Bun.build({
+    entrypoints: ["./packages/dto/index.ts"],
+    outdir: "./packages/dto/dist",
+    target: 'browser',
+    minify: true
+  })
+  console.timeEnd(`🧊 DTO Stage`)
+  console.log(``)
+
+  if (!existsSync(join(cwd(), "milkio.toml"))) return
+  const milkioConfig = (await import(join(cwd(), "milkio.toml"))).default as MilkioConfig
+  if (!milkioConfig?.generate?.significant) return
+  let i = 0
+  for (const command of milkioConfig.generate.significant) {
+    ++i
+    console.time(`🧊 Insignificant Stage (LINE ${i})`)
+    await $`${{ raw: command }}`
+    console.timeEnd(`🧊 Insignificant Stage (LINE ${i})`)
+  }
+}

package/scripts/gen-significant.ts

@@ -0,0 +1,176 @@
+/* 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 { camel, hyphen } from "@poech/camel-hump-under"
+import { $, Glob } from "bun"
+import { MilkioConfig } from ".."
+
+export default async () => {
+  // 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
+
+  // 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"))
+
+  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.")
+  }
+
+  const utils = {
+    camel: (str: string) => camel(str).replaceAll("-", "").replaceAll("_", ""),
+    hyphen: (str: string) => hyphen(str).replaceAll("_", "")
+  }
+
+  // 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") }))
+
+
+  console.time(`🧊 File Stage`)
+  
+
+  for (const path of appFiles) {
+    if (!path.endsWith(".ts")) continue
+    const module = await import(/* @vite-ignore */ join(cwd(), "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))
+  
+  console.timeEnd(`🧊 File Stage`)
+  console.log(``)
+
+  // typia
+  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.log(``)
+
+  if (!existsSync(join(cwd(), "milkio.toml"))) return
+  const milkioConfig = (await import(join(cwd(), "milkio.toml"))).default as MilkioConfig
+  if (!milkioConfig?.generate?.significant) return
+  let i = 0
+  for (const command of milkioConfig.generate.significant) {
+    ++i
+    console.time(`🧊 Significant Stage (LINE ${i})`)
+    await $`${{ raw: command }}`
+    console.timeEnd(`🧊 Significant Stage (LINE ${i})`)
+  }
+}