milkio 0.8.2 → 1.0.0-alpha.0

package/package.json

@@ -2,27 +2,23 @@
   "name": "milkio",
   "type": "module",
   "module": "index.ts",
-  "version": "0.8.2",
+  "version": "1.0.0-alpha.0",
   "peerDependencies": {
     "typescript": "^5.4.2"
   },
-  "bin": {
-    "milkio": "./c.ts"
-  },
+  "scripts": {},
   "dependencies": {
+    "@paralleldrive/cuid2": "^2.2.2",
     "@poech/camel-hump-under": "^1.1.0",
-    "@southern-aurora/tson": "2.0.2",
+    "@southern-aurora/tson": "^2.0.2",
     "chalk": "^5.3.0",
-    "ejs": "^3.1.9",
-    "typia": "5.5.5",
-    "ulidx": "^2.3.0"
+    "date-fns": "^4.1.0",
+    "typia": "6.9.0"
   },
   "devDependencies": {
     "@types/bun": "latest",
-    "@types/node": "latest",
-    "@types/ejs": "^3.1.5",
-    "@types/js-beautify": "^1.14.3",
-    "ts-patch": "^3.1.2",
-    "typescript": "^5.3.3"
+    "@vitest/ui": "^2.0.5",
+    "typescript": "^5.5.0",
+    "vitest": "^2.0.5"
   }
 }

package/stream/index.ts

@@ -0,0 +1,19 @@
+import { type $context, type $meta } from "..";
+
+export const stream = <StreamInitT extends StreamInit>(init: StreamInitT): Stream<StreamInitT> => {
+  const stream = init as unknown as Stream<StreamInitT>;
+  stream.$milkioType = "stream";
+  if (stream.meta === undefined) stream.meta = {};
+  return stream;
+};
+
+export type StreamInit = {
+  meta?: $meta;
+  handler: (context: $context, params: any) => AsyncGenerator<unknown>;
+};
+
+export type Stream<StreamInitT extends StreamInit> = {
+  $milkioType: "stream";
+  meta: StreamInitT["meta"] extends undefined ? {} : StreamInitT["meta"];
+  handler: StreamInitT["handler"];
+};

package/test/index.ts

@@ -0,0 +1,21 @@
+import { type context, type meta } from "..";
+
+export const test = <TestInitT extends TestInit>(init: TestInitT): Test<TestInitT> => {
+  const test = init as unknown as Test<TestInitT>;
+  test.$milkioType = "test";
+  if (test.name === undefined) test.name = {};
+  return test;
+};
+
+export type TestInit = {
+  name: meta;
+  handler: (test: TestTools) => Promise<unknown>;
+};
+
+export type Test<TestInitT extends TestInit> = {
+  $milkioType: "test";
+  name: TestInitT["name"] extends undefined ? {} : TestInitT["name"];
+  handler: TestInitT["handler"];
+};
+
+export type TestTools = {};

package/types/index.ts

@@ -0,0 +1,74 @@
+import { type $rejectCode } from "..";
+
+export interface $types {
+  [key: string]: Record<any, any>;
+}
+
+export type Override<P, S> = Omit<P, keyof S> & S;
+
+export type Mixin<T, U> = U & Omit<T, keyof U>;
+
+export type GeneratorGeneric<T> = T extends AsyncGenerator<infer I> ? I : never;
+
+export type ExecuteId = string | "global";
+
+// DON'T TRY TO WRITE A MORE DETAILED TYPE FOR THIS TYPE
+// the role of this type is only to limit the foolproof operation when defineMilkio(...)
+// the real generated type is defined by the framework user through declare module
+export type GeneratedInit = {
+  routeSchema: any;
+  commandSchema: any;
+  testSchema: any;
+};
+
+export type Results<T extends unknown> = {
+  value: T;
+};
+
+export type ExecuteOptions = {
+  params?: Record<any, any>;
+  headers?: Record<string, string>;
+};
+
+export type Ping =
+  | [
+      {
+        connect: false;
+        delay: number;
+        error: any;
+      },
+      null,
+    ]
+  | [
+      null,
+      {
+        connect: true;
+        delay: number;
+        serverTimestamp: number;
+      },
+    ];
+
+export type Execute = <Path extends keyof $types["generated"]["routeSchema"]["$types"]>(
+  path: Path,
+  options?: Mixin<
+    ExecuteOptions,
+    {
+      headers?: Record<string, string>;
+      params?: $types["generated"]["routeSchema"]["$types"][Path]["params"];
+    }
+  >,
+) => $types["generated"]["routeSchema"]["$types"][Path]["🐣"] extends boolean
+  ? // action
+    Promise<[Partial<$rejectCode>, null, ExecuteResultsOption] | [null, ExecuteActionResults<Path>, ExecuteResultsOption]>
+  : // stream
+    Promise<[Partial<$rejectCode>, null, ExecuteResultsOption] | [null, AsyncGenerator<[Partial<$rejectCode>, null] | [null, ExecuteStreamResults<Path>], null>, ExecuteResultsOption]>;
+
+export type ExecuteResultsOption = { executeId: string };
+
+export type ExecuteActionResults<Path extends keyof Generated["routeSchema"]["$types"], Generated extends $types["generated"] = $types["generated"]> = Generated["routeSchema"]["$types"][Path]["result"];
+
+export type ExecuteStreamResults<Path extends keyof Generated["routeSchema"]["$types"], Generated extends $types["generated"] = $types["generated"]> = GeneratorGeneric<Generated["routeSchema"]["$types"][Path]["result"]>;
+
+export type MilkioResponseReject<Code extends keyof $rejectCode = keyof $rejectCode> = { success: false; code: Code; reject: $rejectCode[Code]; executeId: string };
+
+export type MilkioResponseSuccess<Path extends keyof Generated["routeSchema"]["$types"], Generated extends $types["generated"] = $types["generated"]> = { success: true; data: Generated["routeSchema"]["$types"][Path]["result"]; executeId: string };

package/utils/create-id.ts

@@ -0,0 +1,3 @@
+import { createId as _createId } from "@paralleldrive/cuid2";
+
+export const createId = _createId;

package/world/index.ts

@@ -0,0 +1,65 @@
+import { __initCommander, __initListener, ExecuteId, type Logger, type Mixin, type GeneratedInit, $types, Execute, Ping } from "..";
+import { __initExecuter } from "../execute";
+import { defineDefaultExecuteIdGenerator } from "../execute/execute-id-generator";
+
+export type MilkioInit = {
+  port: {
+    app: number;
+    develop: number | "disabled";
+  };
+  getRealIp?: (request: Request) => string;
+  executeIdGenerator?: (request: Request) => string | Promise<string>;
+  corsAllowMethods?: string;
+  corsAllowHeaders?: string;
+  corsAllowOrigin?: string;
+  ignorePathLevel?: number;
+};
+
+export type MilkioRuntimeInit<T extends MilkioInit> = Mixin<
+  T,
+  {
+    executeIdGenerator: (request: Request) => string | Promise<string>;
+    runtime: {
+      request: Map<ExecuteId, { logger: Logger }>;
+    };
+  }
+>;
+
+export const createWorld = async <CookbookOptions extends MilkioInit>(generated: GeneratedInit, options: CookbookOptions): Promise<MilkioWorld<CookbookOptions>> => {
+  const executeIdGenerator = options.executeIdGenerator ?? defineDefaultExecuteIdGenerator();
+
+  const runtime = {
+    request: new Map(),
+  } as MilkioRuntimeInit<CookbookOptions>["runtime"];
+
+  const _: MilkioRuntimeInit<CookbookOptions> = {
+    ...options,
+    executeIdGenerator,
+    runtime,
+  };
+
+  const executer = __initExecuter(generated, _);
+  const commander = __initCommander(generated, _);
+  const listener = __initListener(generated, _, executer);
+
+  // Initialize the app
+  const app = {
+    _: _,
+    _executer: executer,
+    execute: executer.execute,
+    ping: executer.ping,
+    commander,
+    listener,
+  };
+
+  return app as MilkioWorld<CookbookOptions>;
+};
+
+export type MilkioWorld<CookbookOptions extends MilkioInit = MilkioInit> = {
+  _: MilkioRuntimeInit<CookbookOptions>;
+  _executer: Awaited<ReturnType<typeof __initExecuter<MilkioRuntimeInit<CookbookOptions>>>>;
+  commander: Awaited<ReturnType<typeof __initCommander<MilkioRuntimeInit<CookbookOptions>>>>;
+  listener: Awaited<ReturnType<typeof __initListener<MilkioRuntimeInit<CookbookOptions>>>>;
+  execute: Execute;
+  ping: (options?: { timeout?: number }) => Promise<Ping>;
+};

package/api-test/index.ts

@@ -1,122 +0,0 @@
-import chalk from "chalk";
-import schema from "../../../generated/api-schema";
-import { ExecuteResultFail, reject, type MilkioApp } from "..";
-import { handleCatchError } from "../utils/handle-catch-error.ts";
-
-export const executeApiTests = async <Path extends Array<keyof (typeof schema)["apiTestsSchema"]>>(app: MilkioApp, path: Path | string | true | 1 | undefined) => {
-	console.log(`${chalk.hex("#81C7D4")(`🧊 test running`)}`);
-
-	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 startedAt = new Date().getTime();
-	const apiTestHooks = await import("../../../src/api-test.ts");
-	await apiTestHooks.default.onBootstrap();
-	const clientPackage = apiTestHooks.default?.client ? await apiTestHooks.default?.client() : undefined;
-	const results: Array<{ path: string; case: number; fail: boolean; failMessage?: string }> = [];
-
-	if (!clientPackage) {
-		console.log(`🚨 For testing purposes, if the client package does not exist, subsequent operations might result in errors.`);
-		console.log(`🚨 To disable this warning and ensure the test system runs correctly:`);
-		console.log(` - Run: \`bun i packages/client && cd packages/client && bun i milkio-client\``);
-		console.log(` - Edit: \`src/api-test.ts\``);
-		console.log(` - Add: \`client: () => createClient({ baseUrl: "http://localhost:9000/", memoryStorage: true }),\``);
-		console.log(` - The \`createClient\` method is imported from your client package. If you haven't changed the name in \`packages/client/package.json\`, you can use: \`import { createClient } from 'client';\`.`);
-	} else {
-		let done = false;
-		for (let index = 0; index < 160; index++) {
-			let response;
-			try {
-				response = await fetch(typeof clientPackage.options.baseUrl === "string" ? clientPackage.options.baseUrl : await clientPackage.options.baseUrl(), { method: "GET" });
-			} catch (error: any) {
-				if (error?.status && error.status < 500) {
-					done = true;
-					break;
-				}
-			}
-			if (response?.status && response.status < 500) {
-				console.warn(response, response.status);
-
-				done = true;
-				break;
-			}
-			await new Promise((resolve) => setTimeout(resolve, 100));
-			continue;
-		}
-		if (!done) {
-			console.log(`🚨 The server startup exceeded the maximum waiting time (16000ms).`);
-			console.log(`This is likely an error encountered during the startup of the Milkio Server. Please check the 'Milkio Run & Watch' tab in your VS Code terminal panel. This is only a warning, and the tests will continue, but there is a chance they might fail due to network issues.\n`);
-		}
-	}
-
-	const client = clientPackage
-		? {
-				execute: async (options?: any) => clientPackage!.execute(path as any, options),
-				executeOther: async (path: any, options?: any) => clientPackage!.execute(path as any, options),
-				executeStream: async (options?: any) => clientPackage!.executeStream(path as any, options),
-				executeStreamOther: async (path: any, options?: any) => clientPackage!.executeStream(path as any, options),
-			}
-		: undefined;
-
-	console.log(chalk.hex("#0B346E")(`₋₋₋₋₋₋₋₋`));
-
-	for (const pathRaw of pathArr) {
-		let path = pathRaw.replaceAll("\\", "/");
-		if (path.startsWith("/")) path = path.slice(1) as Path[number];
-
-		// @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();
-			let fail = false;
-			let failMessage: string | undefined = undefined;
-			try {
-				await cs.handler({
-					...((await apiTestHooks.default.onBefore()) ?? {}),
-					log: (...args: Array<unknown>) => console.log(...args),
-					execute: async (options?: any) => app.execute(path as any, options),
-					executeOther: async (path: any, options?: any) => app.execute(path as any, options),
-					executeStream: async (options?: any) => app.executeStream(path as any, options),
-					executeStreamOther: async (path: any, options?: any) => app.executeStream(path as any, options),
-					client,
-					randParams: () => app.randParams(path as any),
-					randOtherParams: (path: any) => app.randParams(path),
-					reject: (message?: string) => {
-						fail = true;
-						failMessage = message;
-						return reject("BUSINESS_FAIL", message ?? "test failed");
-					},
-				});
-			} catch (e: any) {
-				const response = handleCatchError(e, "no-execute-id") as ExecuteResultFail;
-				fail = true;
-				failMessage = response.fail.message;
-			}
-			if (fail) {
-				console.log(`${chalk.hex("#D75455")(`\nrejected`)}${chalk.hex("#999A9E")(` · ${cs.name} | path: src/apps/${path as string}.ts | case: ${i} | time: ${new Date().getTime() - csStartedAt}ms`)}`);
-				console.log(chalk.hex("#999A9E")(failMessage ?? "Test not satisfied"));
-			} else {
-				console.log(`${chalk.hex("#1B813E")(`directed`)}${chalk.hex("#999A9E")(` · ${cs.name} | path: src/apps/${path as string}.ts | case: ${i} | time: ${new Date().getTime() - csStartedAt}ms`)}`);
-			}
-			results.push({ path, case: i, fail, failMessage });
-			console.log(chalk.hex("#0B346E")(`₋₋₋₋₋₋₋₋`));
-			await new Promise((resolve) => setTimeout(resolve, 64));
-		}
-	}
-
-	const endedAt = new Date().getTime();
-
-	const failTotal = results.filter((r) => r.fail).length;
-	const passTotal = results.length - failTotal;
-
-	console.log("");
-	if (failTotal === 0) console.log(chalk.hex("#1B813E")(`🥳 all tests ${chalk.hex("#1B813E")(`passed`)} ${chalk.hex("#999A9E")(`🌟 milkio testing took ${((endedAt - startedAt) / 1000).toFixed(2)}s\n`)}`));
-	else console.log(chalk.hex("#999A9E")(`🤗️️ ${failTotal} test${failTotal > 1 ? "s" : ""} ${chalk.hex("#D75455")(`failed`)}${passTotal > 0 ? `, and ${results.length - failTotal} ${chalk.hex("#1B813E")(`passed`)}` : ""} ${chalk.hex("#999A9E")(`🌟 milkio testing took ${((endedAt - startedAt) / 1000).toFixed(2)}s`)}`));
-};

package/c.ts

@@ -1,50 +0,0 @@
-#!/usr/bin/env bun
-
-import { argv, exit } from "node:process";
-import { $, env } from "bun";
-
-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 {
-			console.clear();
-		} catch (e) {}
-		const command = Buffer.from(commandBase64ed, "base64").toString("utf-8");
-		console.log("\x1B[2m%s\x1B[0m", `$ ${command}`);
-		console.log(``);
-		try {
-			await $`${{ raw: command }}`.env({ ...env, FORCE_COLOR: "3" });
-		} catch (e) {}
-		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);
-}
-
-// @ts-ignore
-await commands[method](...params);
-
-exit(0);

package/defines/define-api-test.ts

@@ -1,69 +0,0 @@
-import type { Api, ExecuteResult, ExecuteOptions, GeneratorGeneric, ExecuteResultSuccess } 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,
-	};
-}
-
-export type ApiTestCases<ApiT extends Api> = {
-	handler: (
-		test: {
-			log: (...params: Array<unknown>) => void;
-			execute: (options: { params: Parameters<ApiT["action"]>[0]; headers?: Record<string, string> } & 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,
-				options: {
-					params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string;
-					headers?: Record<string, string>;
-				} & ExecuteOptions,
-			) => Promise<ExecuteResult<Result>>;
-			executeStream: (options: { params: Parameters<ApiT["action"]>[0]; headers?: Record<string, string> } & ExecuteOptions) => Promise<{
-				getResult: () => ExecuteResult<undefined>;
-				stream: AsyncGenerator<Awaited<ReturnType<ApiT["action"]>>>;
-			}>;
-			executeStreamOther: <Path extends keyof (typeof schema)["apiMethodsTypeSchema"], Result extends Awaited<ReturnType<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>>>(
-				path: Path,
-				options: { params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string; headers?: Record<string, string> } & ExecuteOptions,
-			) => Promise<{
-				getResult: () => ExecuteResult<undefined>;
-				stream: AsyncGenerator<Result>;
-			}>;
-			client: {
-				execute: (options: { params: Parameters<ApiT["action"]>[0]; headers?: Record<string, string> } & 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,
-					options: {
-						params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string;
-						headers?: Record<string, string>;
-					} & ExecuteOptions,
-				) => Promise<ExecuteResult<Result>>;
-				executeStream: (options: { params: Parameters<ApiT["action"]>[0]; headers?: Record<string, string> } & ExecuteOptions) => Promise<{
-					getResult: () => ExecuteResult<undefined>;
-					stream: AsyncGenerator<Awaited<ReturnType<ApiT["action"]>>>;
-				}>;
-				executeStreamOther: <Path extends keyof (typeof schema)["apiMethodsTypeSchema"], Result extends Awaited<ReturnType<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>>>(
-					path: Path,
-					options: { params: Parameters<(typeof schema)["apiMethodsTypeSchema"][Path]["api"]["action"]>[0] | string; headers?: Record<string, string> } & ExecuteOptions,
-				) => Promise<{
-					getResult: () => ExecuteResult<undefined>;
-					stream: AsyncGenerator<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) => {
-				name: string;
-				code: "BUSINESS_FAIL";
-				message: string;
-				data: string;
-				stack: string;
-			};
-		} & Awaited<ReturnType<(typeof apiTestHooks)["onBefore"]>>,
-	) => Promise<void> | void;
-	name: string;
-	timeout?: number;
-};

package/defines/define-api.ts

@@ -1,11 +0,0 @@
-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 };
-}
-
-export type Api = {
-	meta: Meta;
-	action: (params: any, context: Context) => Promise<unknown> | unknown;
-};

package/defines/define-command-handler.ts

@@ -1,47 +0,0 @@
-import type { MilkioApp } from "..";
-
-export type CommandOptions = {
-	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] ?? "default"}`;
-
-		// @ts-ignore
-		const result = await app.execute(params.path as any, { params: params });
-		if (!result.success) {
-			if (result.fail.code === "NOT_FOUND") {
-				if (options.notFoundHandler) await options.notFoundHandler({ ...params, name: argv.length === 2 ? "default" : argv[2] ?? "default" });
-				return;
-			}
-			if (result.fail.code !== "INTERNAL_SERVER_ERROR") {
-				console.log(result.fail.message);
-				return;
-			}
-		}
-	};
-
-	return call;
-}

package/defines/define-config.ts

@@ -1,32 +0,0 @@
-export function defineConfig<T>(handler: (options: { config: typeof configFn }) => T): T {
-	const result = handler({ config: configFn });
-	if (!result) throw new Error("defineConfig must return a value, Did you forget to add a return statement?");
-	if (typeof result !== "object" || Array.isArray(result)) throw new Error("defineConfig must return an object.");
-	if ("environment" in result && "done" in result && typeof result["environment"] === "function" && typeof result["done"] === "function") throw new Error("Did you accidentally return the config method without adding `.done()`?");
-	return result;
-}
-
-function configFn<ConfigT extends Config>(config: ConfigT): ConfigMore<ConfigT> {
-	let skipMore = false;
-
-	const configMore: ConfigMore<ConfigT> = {
-		environment: (when, configMixin) => {
-			if (skipMore || !when()) return configMore;
-			skipMore = true;
-			for (const key in configMixin) (config as any)[key] = configMixin[key];
-			return configMore;
-		},
-		done: () => {
-			return config;
-		},
-	} satisfies ConfigMore<ConfigT>;
-
-	return configMore;
-}
-
-export type Config = Record<string, unknown>;
-
-export type ConfigMore<ConfigT extends Config> = {
-	environment: (when: () => boolean, config: Partial<ConfigT>) => ConfigMore<ConfigT>;
-	done: () => ConfigT;
-};