milkio 0.1.2 → 0.2.1

package/api-test/index.ts

@@ -1,71 +1,69 @@
-/* eslint-disable no-constant-condition, @typescript-eslint/no-unsafe-argument, no-console, @typescript-eslint/no-explicit-any */
-
-import schema from "../../../generated/api-schema"
-import { useLogger, type MilkioApp } from ".."
+import schema from "../../../generated/api-schema";
+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`)
-  
-  let pathArr = [] as Array<string>
-  if (!path || path === "1" || path === 1 || path === true) {
-    pathArr = Object.keys(schema.apiTestsSchema) as unknown as Path
-  } else if (typeof path === "string") {
-    pathArr = [path] as Path
-  }
-  
-  const tests = []
-  const startedAt = new Date().getTime()
+	console.log(`🥛 Milkio Api Testing..\n`);
+
+	let pathArr = [] as Array<string>;
+	if (!path || path === "1" || path === 1 || path === true) {
+		pathArr = Object.keys(schema.apiTestsSchema) as unknown as Path;
+	} else if (typeof path === "string") {
+		pathArr = [path] as Path;
+	}
+
+	const tests = [];
+	const startedAt = new Date().getTime();
+
+	const apiTestHooks = await import("../../../src/api-test.ts");
+	await apiTestHooks.default.onBootstrap();
+
+	for (let path of pathArr) {
+		if (path.startsWith("/")) path = path.slice(1) as Path[number];
+
+		tests.push(
+			// @ts-ignore
+			(async () => {
+				// @ts-ignore
+				const module = await schema.apiTestsSchema[path]().module;
+				const cases = module.test.getCases();
+				let i = 0;
+				for (const cs of cases) {
+					++i;
+					const csStartedAt = new Date().getTime();
+					const clear = setTimeout(() => {
+						console.error(`------`);
+						console.error(`❌ TIMEOUT -- More than ${cs.timeout ?? 8192}ms`);
+						console.error(`   ${cs.name} | Path: src/apps/${path as string}.ts | Case: ${i}`);
+						console.error(`------`);
+						throw new Error("");
+					}, cs.timeout ?? 8192);
+					await cs.handler({
+						...((await apiTestHooks.default.onBefore()) ?? {}),
+						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"}`);
+							console.error(`   ${cs.name} | Path: src/apps/${path as string}.ts | Case: ${i} | Time: ${new Date().getTime() - csStartedAt}ms`);
+							console.error(`------`);
+							throw new Error("");
+						},
+					} as any);
+					clearTimeout(clear);
+					console.log(`✅ DIRECT --  ${cs.name} | Path: src/apps/${path as string}.ts | Case: ${i} | Time: ${new Date().getTime() - csStartedAt}ms`);
+				}
+			})(),
+		);
+	}
+
+	await Promise.all(tests);
 
-  const apiTestHooks = await import("../../../src/api-test.ts")
-  await apiTestHooks.default.onBootstrap()
-  
-  for (let path of pathArr) {
-    if (path.startsWith("/")) path = path.slice(1) as Path[number]
+	const endedAt = new Date().getTime();
 
-    tests.push(
-      // @ts-ignore
-      (async () => {
-        // @ts-ignore
-        const module = await schema.apiTestsSchema[path]().module
-        const cases = module.test.getCases()
-        let i = 0
-        for (const cs of cases) {
-          ++i
-          const csStartedAt = new Date().getTime()
-          const clear = setTimeout(() => {
-            console.error(`------`)
-            console.error(`❌ TIMEOUT -- More than ${cs.timeout ?? 8192}ms`)
-            console.error(`   ${cs.name} | Path: src/apps/${path as string}.ts | Case: ${i}`)
-            console.error(`------`)
-            throw new Error("")
-          }, cs.timeout ?? 8192)
-          await cs.handler({
-            ...(await apiTestHooks.default.onBefore()) ?? {},
-            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"}`)
-              console.error(`   ${cs.name} | Path: src/apps/${path as string}.ts | Case: ${i} | Time: ${new Date().getTime() - csStartedAt}ms`)
-              console.error(`------`)
-              throw new Error("")
-            }
-          } as any)
-          clearTimeout(clear)
-          console.log(`✅ DIRECT --  ${cs.name} | Path: src/apps/${path as string}.ts | Case: ${i} | Time: ${new Date().getTime() - csStartedAt}ms`)
-        }
-      })()
-    )
-  }
-  
-  await Promise.all(tests)
-  
-  const endedAt = new Date().getTime()
-  
-  console.log(`\n✅ All tests passed.`)
-  console.log(`🥛 Milkio Api Testing took ${((endedAt - startedAt) / 1000).toFixed(2)}s\n`)
-}
+	console.log(`\n✅ All tests passed.`);
+	console.log(`🥛 Milkio Api Testing took ${((endedAt - startedAt) / 1000).toFixed(2)}s\n`);
+};

package/c.ts

@@ -1,48 +1,48 @@
 #!/usr/bin/env bun
 
-/* eslint-disable no-constant-condition, @typescript-eslint/no-misused-promises, no-console, @typescript-eslint/no-explicit-any */
+import { argv, exit } from "node:process";
+import { $ } from "bun";
 
-import { argv, exit } from "node:process"
-import { $ } from "bun"
-
-const method = argv[2] as keyof typeof commands
-const params = argv.slice(3) as Parameters<(typeof commands)[keyof typeof commands]>
+const method = argv[2] as keyof typeof commands;
+const params = argv.slice(3) as Parameters<(typeof commands)[keyof typeof commands]>;
 
 const commands = {
-  async gen() {
-    console.log("🥛 Milkio Generating..\n")
-    await (await import('./scripts/gen-significant')).default()
-    await (await import('./scripts/gen-insignificant')).default()
-    console.log("\n✅ Milkio Generated!")
-  },
-  async "gen:significant"() {
-    console.log("🥛 Milkio Significant Generating..\n")
-    await (await import('./scripts/gen-significant')).default()
-    console.log("\n✅ Milkio Significant Generated!")
-  },
-  async "gen:insignificant"() {
-    console.log("🥛 Milkio Insignificant Generating..\n")
-    await (await import('./scripts/gen-insignificant')).default()
-    console.log("\n✅ Milkio Insignificant Generated!")
-  },
-  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}`)
-    console.log(``)
-    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))
-  },
-}
+	async gen() {
+		console.log("🥛 Milkio Generating..\n");
+		await (await import("./scripts/gen-significant")).default();
+		await (await import("./scripts/gen-insignificant")).default();
+		console.log("\n✅ Milkio Generated!");
+	},
+	async "gen:significant"() {
+		console.log("🥛 Milkio Significant Generating..\n");
+		await (await import("./scripts/gen-significant")).default();
+		console.log("\n✅ Milkio Significant Generated!");
+	},
+	async "gen:insignificant"() {
+		console.log("🥛 Milkio Insignificant Generating..\n");
+		await (await import("./scripts/gen-insignificant")).default();
+		console.log("\n✅ Milkio Insignificant Generated!");
+	},
+	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}`);
+		console.log(``);
+		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));
+	},
+};
 
 if (method === undefined || !(method in commands)) {
-  console.log("Command does not exist, Supported commands are:")
-  console.log("  " + Object.keys(commands).join(", "))
-  exit(1)
+	console.log("Command does not exist, Supported commands are:");
+	console.log(`  ${Object.keys(commands).join(", ")}`);
+	exit(1);
 }
 
 // @ts-ignore
-await commands[method](...params)
+await commands[method](...params);
 
-exit(0)
+exit(0);

package/defines/define-api-test.ts

@@ -1,23 +1,30 @@
-import { type Api, type ExecuteResult, type ExecuteOptions } from ".."
-import type schema from "../../../generated/api-schema"
-import type apiTestHooks from "../../../src/api-test.ts"
+import type { Api, ExecuteResult, ExecuteOptions } from "..";
+import type schema from "../../../generated/api-schema";
+import type apiTestHooks from "../../../src/api-test.ts";
 
 export function defineApiTest<ApiT extends Api>(_api: ApiT, cases: Array<ApiTestCases<ApiT>>) {
-  return {
-    getCases: () => cases,
-    isApiTest: true
-  }
+	return {
+		getCases: () => cases,
+		isApiTest: true,
+	};
 }
 
 export type ApiTestCases<ApiT extends Api> = {
-  handler: (test: {
-    log: (...params: Array<unknown>) => void;
-    execute: (params: Parameters<ApiT["action"]>[0], headers?: Record<string, string>, options?: ExecuteOptions) => Promise<ExecuteResult<Awaited<ReturnType<ApiT["action"]>>>>;
-    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>>;
-    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;
-  } & Awaited<ReturnType<(typeof apiTestHooks)['onBefore']>>) => Promise<void> | void;
-  name: string;
-  timeout?: number;
+	handler: (
+		test: {
+			log: (...params: Array<unknown>) => void;
+			execute: (params: Parameters<ApiT["action"]>[0], headers?: Record<string, string>, options?: ExecuteOptions) => Promise<ExecuteResult<Awaited<ReturnType<ApiT["action"]>>>>;
+			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>>;
+			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;
+		} & Awaited<ReturnType<(typeof apiTestHooks)["onBefore"]>>,
+	) => Promise<void> | void;
+	name: string;
+	timeout?: number;
 };

package/defines/define-api.ts

@@ -1,15 +1,15 @@
-import type { Meta } from "../../../src/meta"
-import type { Context } from "../../../src/context"
+import type { Meta } from "../../../src/meta";
+import type { Context } from "../../../src/context";
 
 export function defineApi<ApiT extends Api>(api: ApiT): ApiT & { isApi: true } {
-  return {
-    ...api,
-    isApi: true
-  }
+	return {
+		...api,
+		isApi: true,
+	};
 }
 
 export type Api = {
-  meta: Meta;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  action: (params: any, context: Context) => Promise<unknown> | unknown;
+	meta: Meta;
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	action: (params: any, context: Context) => Promise<unknown> | unknown;
 };

package/defines/define-command-handler.ts

@@ -1,48 +1,47 @@
-/* eslint-disable no-console, @typescript-eslint/no-explicit-any */
-import type { MilkioApp } from ".."
+import type { MilkioApp } from "..";
 
 export type CommandOptions = {
-  notFoundHandler?: (event: { name: string, path: string, commands: Array<string>, options: Record<string, string | true> }) => void | Promise<void>;
-}
+	notFoundHandler?: (event: { name: string; path: string; commands: Array<string>; options: Record<string, string | true> }) => void | Promise<void>;
+};
 
 export function defineCommandHandler(app: MilkioApp, options: CommandOptions = {}) {
-  const call = async (argv: Array<string>) => {
-    const params = {
-      path: 'default',
-      commands: [] as Array<string>,
-      options: {} as Record<string, string | true>
-    }
-    for (const v of argv.slice(3)) {
-      if (v.startsWith("--") && v.includes('=')) {
-        const vSplited = v.split("=")
-        params.options[vSplited[0].slice(2)] = vSplited.slice(1, vSplited.length).join("=")
-      } else if (v.startsWith("--")) {
-        params.options[v.slice(2)] = true
-      } else if (v.startsWith("-") && v.includes('=')) {
-        const vSplited = v.split("=")
-        params.options[vSplited[0].slice(1)] = vSplited.slice(1, vSplited.length).join("=")
-      } else if (v.startsWith("-")) {
-        params.options[v.slice(1)] = true
-      } else {
-        params.commands.push(v)
-      }
-    }
-    if (argv.length === 2) params.path = `$/default`
-    else params.path = `$/${argv[2]}`
+	const call = async (argv: Array<string>) => {
+		const params = {
+			path: "default",
+			commands: [] as Array<string>,
+			options: {} as Record<string, string | true>,
+		};
+		for (const v of argv.slice(3)) {
+			if (v.startsWith("--") && v.includes("=")) {
+				const vSplited = v.split("=");
+				params.options[vSplited[0].slice(2)] = vSplited.slice(1, vSplited.length).join("=");
+			} else if (v.startsWith("--")) {
+				params.options[v.slice(2)] = true;
+			} else if (v.startsWith("-") && v.includes("=")) {
+				const vSplited = v.split("=");
+				params.options[vSplited[0].slice(1)] = vSplited.slice(1, vSplited.length).join("=");
+			} else if (v.startsWith("-")) {
+				params.options[v.slice(1)] = true;
+			} else {
+				params.commands.push(v);
+			}
+		}
+		if (argv.length === 2) params.path = `$/default`;
+		else params.path = `$/${argv[2]}`;
 
-    // @ts-ignore
-    const result = await app.execute(params.path as any, params)
-    if (!result.success) {
-      if (result.fail.code === 'NOT_FOUND') {
-        if (options.notFoundHandler) await options.notFoundHandler({ ...params, name: argv.length === 2 ? 'default' : argv[2] })
-        return
-      }
-      if (result.fail.code !== 'INTERNAL_SERVER_ERROR') {
-        console.log(result.fail.message)
-        return
-      }
-    }
-  }
+		// @ts-ignore
+		const result = await app.execute(params.path as any, params);
+		if (!result.success) {
+			if (result.fail.code === "NOT_FOUND") {
+				if (options.notFoundHandler) await options.notFoundHandler({ ...params, name: argv.length === 2 ? "default" : argv[2] });
+				return;
+			}
+			if (result.fail.code !== "INTERNAL_SERVER_ERROR") {
+				console.log(result.fail.message);
+				return;
+			}
+		}
+	};
 
-  return call
-}
+	return call;
+}