@izumisy-tailor/omakase-modules 0.1.0 → 0.2.0

package/src/builder/helpers.ts

@@ -0,0 +1,51 @@
+type ModuleBuilderProps<C extends Record<string, unknown>> = {
+  config: C;
+};
+
+export type ConfiguredModule<
+  C extends Record<string, unknown> = Record<string, unknown>
+> = {
+  packageName: string;
+  moduleProps: ModuleBuilderProps<C>;
+};
+
+export type DefinedModule<
+  C extends Record<string, unknown>,
+  Tables extends Record<string, unknown> = Record<string, unknown>
+> = {
+  packageName: string;
+  configure: (props: ModuleBuilderProps<C>) => ConfiguredModule<C>;
+  /**
+   * @internal Type-only hook so that table shapes flow through helper utilities.
+   */
+  readonly __tablesBrand?: Tables;
+};
+
+export const defineModule = <
+  C extends Record<string, unknown>,
+  Tables extends Record<string, unknown> = Record<string, unknown>
+>(baseProps: {
+  /**
+   * The package name of the module.
+   *
+   * This is required to be the same as the name field in package.json
+   */
+  packageName: string;
+}): DefinedModule<C, Tables> => {
+  return {
+    packageName: baseProps.packageName,
+    configure: (props) => {
+      return {
+        packageName: baseProps.packageName,
+        moduleProps: props,
+      };
+    },
+  };
+};
+
+export type ModuleDependency<T extends DefinedModule<any, any>> =
+  T extends DefinedModule<infer C, infer Tables>
+    ? ConfiguredModule<C> & {
+        readonly __tablesBrand?: Tables;
+      }
+    : never;

package/src/builder/index.ts

@@ -0,0 +1,7 @@
+export {
+  defineModule,
+  type ConfiguredModule,
+  type DefinedModule,
+  type ModuleDependency,
+} from "./helpers";
+export { withModuleConfiguration } from "./register";

package/src/builder/register.ts

@@ -0,0 +1,34 @@
+import type { ModuleConfigLoaderReturn } from "../stub-loader/interface";
+import type { DefinedModule } from "./helpers";
+
+type ModuleFactoryContext<C extends Record<string, unknown>> = Awaited<
+  ModuleConfigLoaderReturn<C>
+>;
+
+/**
+ * Load a module's configuration, define something.
+ *
+ * THis is a low-level utility composed by a specific builder function.
+ */
+export const withModuleConfiguration = async <
+  C extends Record<string, unknown>,
+  Tables extends Record<string, unknown>,
+  Result
+>(
+  module: DefinedModule<C, Tables>,
+  factory: (context: ModuleFactoryContext<C>) => Result | Promise<Result>
+) => {
+  /**
+   * This import intentionally uses a module path instead of a package path
+   * to let the app override the implementation via tsconfig paths.
+   *
+   * For more details, see `moduleConfigLoader` in `./src/stub-loader/interface.ts`.
+   *
+   * Dynamic import is also important here to avoid "cannot acess before initialization" error.
+   */
+  const { default: configLoader } = await import(
+    "@izumisy-tailor/omakase-modules/config/loader"
+  );
+  const moduleState = await configLoader.loadConfig(module);
+  return await factory(moduleState);
+};

package/src/config/index.ts

@@ -0,0 +1 @@
+export { loadModules, ModuleLoader, type LoadedModules } from "./module-loader";

package/src/config/module-loader.ts

@@ -0,0 +1,85 @@
+import { ConfiguredModule } from "../builder/helpers";
+import {
+  clearModuleRegistry,
+  getConfiguredModule,
+  registerConfiguredModules,
+} from "./module-registry";
+
+/**
+ * Module loader
+ * Builder for registering modules within loadModules
+ */
+export class ModuleLoader {
+  private modules: Array<ConfiguredModule<any>> = [];
+
+  /**
+   * Add a module to the loader
+   * @param module Configured module
+   * @returns The added module (can be used as a dependency for other modules)
+   */
+  add<C extends Record<string, unknown>>(
+    module: ConfiguredModule<C>
+  ): ConfiguredModule<C> {
+    this.modules.push(module);
+    return module;
+  }
+
+  /**
+   * Get all registered modules
+   * @internal
+   */
+  _getModules(): Array<ConfiguredModule<any>> {
+    return this.modules;
+  }
+}
+
+export type LoadedModules = {
+  loadedModules: Record<string, ConfiguredModule<any>>;
+  loadConfig: <C extends Record<string, unknown>>(module: {
+    packageName: string;
+  }) => {
+    config: C;
+  };
+};
+
+/**
+ * Load modules with configuration
+ * @param configurator Function that receives a loader, registers modules, and returns the loader
+ * @returns Loaded modules and loadConfig function
+ */
+export const loadModules = (
+  configurator: (loader: ModuleLoader) => ModuleLoader
+): LoadedModules => {
+  clearModuleRegistry();
+
+  const emptyLoader = new ModuleLoader();
+  const modules = registerConfiguredModules(
+    configurator(emptyLoader)._getModules()
+  );
+
+  const loadedModules = modules.reduce<Record<string, ConfiguredModule<any>>>(
+    (acc, module) => {
+      acc[module.packageName] = module;
+      return acc;
+    },
+    {}
+  );
+
+  return {
+    loadedModules,
+    loadConfig: <C extends Record<string, unknown>>(module: {
+      packageName: string;
+    }) => {
+      const loadedModule = getConfiguredModule(module.packageName);
+      if (!loadedModule) {
+        throw new Error(
+          `Module "${module.packageName}" has not been configured. Ensure it is added via loadModules.`
+        );
+      }
+
+      return {
+        config: loadedModule.moduleProps.config as C,
+      };
+    },
+  };
+};

package/src/config/module-registry.ts

@@ -0,0 +1,22 @@
+import type { ConfiguredModule } from "../builder/helpers";
+
+const registry = new Map<string, ConfiguredModule<any>>();
+
+export const clearModuleRegistry = () => {
+  registry.clear();
+};
+
+export const registerConfiguredModules = (
+  modules: ReadonlyArray<ConfiguredModule<any>>
+) => {
+  modules.forEach((module) => {
+    registry.set(module.packageName, module);
+  });
+  return modules;
+};
+
+export const getConfiguredModule = <C extends Record<string, unknown>>(
+  packageName: string
+): ConfiguredModule<C> | undefined => {
+  return registry.get(packageName) as ConfiguredModule<C> | undefined;
+};

package/src/config/sdk/index.ts

@@ -0,0 +1 @@
+export { getModulesReference } from "./paths";

package/src/config/sdk/paths.ts

@@ -0,0 +1,20 @@
+import path from "node:path";
+import { LoadedModules } from "../module-loader";
+
+export const getModulesReference = (loadedModules: LoadedModules) => {
+  const modulePackageNames = Object.keys(loadedModules.loadedModules);
+
+  return {
+    tailordb: modulePackageNames.map((name) =>
+      path.join("node_modules", name, "src", "tailordb", "*.ts")
+    ),
+
+    resolver: modulePackageNames.map((name) =>
+      path.join("node_modules", name, "src", "resolvers", "*.ts")
+    ),
+
+    executor: modulePackageNames.map((name) =>
+      path.join("node_modules", name, "src", "executors", "*.ts")
+    ),
+  };
+};

package/src/stub-loader/index.ts

@@ -0,0 +1,3 @@
+import { moduleConfigLoader } from "./interface";
+
+export default moduleConfigLoader;

package/src/stub-loader/interface.ts

@@ -0,0 +1,40 @@
+import { DefinedModule } from "../builder";
+
+export type ModuleConfigLoaderReturn<C extends Record<string, unknown>> =
+  Promise<{
+    config: C;
+  }>;
+
+const loadConfig = async <C extends Record<string, unknown>>(
+  _: DefinedModule<C, any>
+): ModuleConfigLoaderReturn<C> => {
+  console.warn(
+    `[warn] Empty module configuration loaded. Override "@izumisy-tailor/omakase-modules/config/loader" to "./modules.ts" in tsconfig.json paths in your app`
+  );
+
+  return {
+    config: {} as C,
+  };
+};
+
+/**
+ * `moduleConfigLoader` is an interface for loading module configurations.
+ *
+ * By default, it throws an error indicating that the loader needs to be overridden in tsconfig.json.
+ * Users should provide their "modules.ts" that calls `loadModules` which implements the actual loading logic.
+ *
+ * @example
+ * ```
+ * {
+ *   "compilerOptions": {
+ *     // ...
+ *     "paths": {
+ *       "@izumisy-tailor/omakase-modules/config/loader": ["./modules.ts"],
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export const moduleConfigLoader = {
+  loadConfig,
+};

package/dist/builder/index.d.mts

@@ -1,3 +0,0 @@
-import { i as defineModule, n as DefinedModule, r as ModuleDependency, t as ConfiguredModule } from "../helpers-CNjRbrYN.mjs";
-import { t as withModuleConfiguration } from "../index-BoAL29Di.mjs";
-export { ConfiguredModule, DefinedModule, ModuleDependency, defineModule, withModuleConfiguration };

package/dist/builder/index.mjs

@@ -1,35 +0,0 @@
-//#region src/builder/helpers.ts
-const defineModule = (baseProps) => {
-	return {
-		packageName: baseProps.packageName,
-		configure: (props) => {
-			return {
-				packageName: baseProps.packageName,
-				moduleProps: props
-			};
-		}
-	};
-};
-
-//#endregion
-//#region src/builder/register.ts
-/**
-* Load a module's configuration, define something.
-*
-* THis is a low-level utility composed by a specific builder function.
-*/
-const withModuleConfiguration = async (module, factory) => {
-	/**
-	* This import intentionally uses a module path instead of a package path
-	* to let the app override the implementation via tsconfig paths.
-	*
-	* For more details, see `moduleConfigLoader` in `./src/stub-loader/interface.ts`.
-	*
-	* Dynamic import is also important here to avoid "cannot acess before initialization" error.
-	*/
-	const { default: configLoader } = await import("@izumisy-tailor/omakase-modules/config/loader");
-	return await factory(await configLoader.loadConfig(module));
-};
-
-//#endregion
-export { defineModule, withModuleConfiguration };

package/dist/config/index.d.mts

@@ -1,2 +0,0 @@
-import { n as ModuleLoader, r as loadModules, t as LoadedModules } from "../module-loader-B4sA1i0A.mjs";
-export { type LoadedModules, ModuleLoader, loadModules };

package/dist/config/index.mjs

@@ -1,62 +0,0 @@
-//#region src/config/module-registry.ts
-const registry = /* @__PURE__ */ new Map();
-const clearModuleRegistry = () => {
-	registry.clear();
-};
-const registerConfiguredModules = (modules) => {
-	modules.forEach((module) => {
-		registry.set(module.packageName, module);
-	});
-	return modules;
-};
-const getConfiguredModule = (packageName) => {
-	return registry.get(packageName);
-};
-
-//#endregion
-//#region src/config/module-loader.ts
-/**
-* Module loader
-* Builder for registering modules within loadModules
-*/
-var ModuleLoader = class {
-	modules = [];
-	/**
-	* Add a module to the loader
-	* @param module Configured module
-	* @returns The added module (can be used as a dependency for other modules)
-	*/
-	add(module) {
-		this.modules.push(module);
-		return module;
-	}
-	/**
-	* Get all registered modules
-	* @internal
-	*/
-	_getModules() {
-		return this.modules;
-	}
-};
-/**
-* Load modules with configuration
-* @param configurator Function that receives a loader, registers modules, and returns the loader
-* @returns Loaded modules and loadConfig function
-*/
-const loadModules = (configurator) => {
-	clearModuleRegistry();
-	return {
-		loadedModules: registerConfiguredModules(configurator(new ModuleLoader())._getModules()).reduce((acc, module) => {
-			acc[module.packageName] = module;
-			return acc;
-		}, {}),
-		loadConfig: (module) => {
-			const loadedModule = getConfiguredModule(module.packageName);
-			if (!loadedModule) throw new Error(`Module "${module.packageName}" has not been configured. Ensure it is added via loadModules.`);
-			return { config: loadedModule.moduleProps.config };
-		}
-	};
-};
-
-//#endregion
-export { ModuleLoader, loadModules };

package/dist/config/sdk/index.d.mts

@@ -1,10 +0,0 @@
-import { t as LoadedModules } from "../../module-loader-B4sA1i0A.mjs";
-
-//#region src/config/sdk/paths.d.ts
-declare const getModulesReference: (loadedModules: LoadedModules) => {
-  tailordb: string[];
-  resolver: string[];
-  executor: string[];
-};
-//#endregion
-export { getModulesReference };

package/dist/config/sdk/index.mjs

@@ -1,14 +0,0 @@
-import path from "node:path";
-
-//#region src/config/sdk/paths.ts
-const getModulesReference = (loadedModules) => {
-	const modulePackageNames = Object.keys(loadedModules.loadedModules);
-	return {
-		tailordb: modulePackageNames.map((name) => path.join("node_modules", name, "dist", "tailordb", "*.mjs")),
-		resolver: modulePackageNames.map((name) => path.join("node_modules", name, "dist", "resolvers", "*.mjs")),
-		executor: modulePackageNames.map((name) => path.join("node_modules", name, "dist", "executors", "*.mjs"))
-	};
-};
-
-//#endregion
-export { getModulesReference };

package/dist/helpers-CNjRbrYN.d.mts

@@ -1,29 +0,0 @@
-//#region src/builder/helpers.d.ts
-type ModuleBuilderProps<C$1 extends Record<string, unknown>> = {
-  config: C$1;
-};
-type ConfiguredModule<C$1 extends Record<string, unknown> = Record<string, unknown>> = {
-  packageName: string;
-  moduleProps: ModuleBuilderProps<C$1>;
-};
-type DefinedModule<C$1 extends Record<string, unknown>, Tables$1 extends Record<string, unknown> = Record<string, unknown>> = {
-  packageName: string;
-  configure: (props: ModuleBuilderProps<C$1>) => ConfiguredModule<C$1>;
-  /**
-   * @internal Type-only hook so that table shapes flow through helper utilities.
-   */
-  readonly __tablesBrand?: Tables$1;
-};
-declare const defineModule: <C$1 extends Record<string, unknown>, Tables$1 extends Record<string, unknown> = Record<string, unknown>>(baseProps: {
-  /**
-   * The package name of the module.
-   *
-   * This is required to be the same as the name field in package.json
-   */
-  packageName: string;
-}) => DefinedModule<C$1, Tables$1>;
-type ModuleDependency<T extends DefinedModule<any, any>> = T extends DefinedModule<infer C, infer Tables> ? ConfiguredModule<C> & {
-  readonly __tablesBrand?: Tables;
-} : never;
-//#endregion
-export { defineModule as i, DefinedModule as n, ModuleDependency as r, ConfiguredModule as t };

package/dist/index-BoAL29Di.d.mts

@@ -1,38 +0,0 @@
-import { n as DefinedModule } from "./helpers-CNjRbrYN.mjs";
-
-//#region src/stub-loader/interface.d.ts
-type ModuleConfigLoaderReturn<C extends Record<string, unknown>> = Promise<{
-  config: C;
-}>;
-/**
- * `moduleConfigLoader` is an interface for loading module configurations.
- *
- * By default, it throws an error indicating that the loader needs to be overridden in tsconfig.json.
- * Users should provide their "modules.ts" that calls `loadModules` which implements the actual loading logic.
- *
- * @example
- * ```
- * {
- *   "compilerOptions": {
- *     // ...
- *     "paths": {
- *       "@izumisy-tailor/omakase-modules/config/loader": ["./modules.ts"],
- *     }
- *   }
- * }
- * ```
- */
-declare const moduleConfigLoader: {
-  loadConfig: <C extends Record<string, unknown>>(_: DefinedModule<C, any>) => ModuleConfigLoaderReturn<C>;
-};
-//#endregion
-//#region src/builder/register.d.ts
-type ModuleFactoryContext<C extends Record<string, unknown>> = Awaited<ModuleConfigLoaderReturn<C>>;
-/**
- * Load a module's configuration, define something.
- *
- * THis is a low-level utility composed by a specific builder function.
- */
-declare const withModuleConfiguration: <C extends Record<string, unknown>, Tables extends Record<string, unknown>, Result>(module: DefinedModule<C, Tables>, factory: (context: ModuleFactoryContext<C>) => Result | Promise<Result>) => Promise<Result>;
-//#endregion
-export { moduleConfigLoader as n, withModuleConfiguration as t };

package/dist/module-loader-B4sA1i0A.d.mts

@@ -1,38 +0,0 @@
-import { t as ConfiguredModule } from "./helpers-CNjRbrYN.mjs";
-
-//#region src/config/module-loader.d.ts
-
-/**
- * Module loader
- * Builder for registering modules within loadModules
- */
-declare class ModuleLoader {
-  private modules;
-  /**
-   * Add a module to the loader
-   * @param module Configured module
-   * @returns The added module (can be used as a dependency for other modules)
-   */
-  add<C extends Record<string, unknown>>(module: ConfiguredModule<C>): ConfiguredModule<C>;
-  /**
-   * Get all registered modules
-   * @internal
-   */
-  _getModules(): Array<ConfiguredModule<any>>;
-}
-type LoadedModules = {
-  loadedModules: Record<string, ConfiguredModule<any>>;
-  loadConfig: <C extends Record<string, unknown>>(module: {
-    packageName: string;
-  }) => {
-    config: C;
-  };
-};
-/**
- * Load modules with configuration
- * @param configurator Function that receives a loader, registers modules, and returns the loader
- * @returns Loaded modules and loadConfig function
- */
-declare const loadModules: (configurator: (loader: ModuleLoader) => ModuleLoader) => LoadedModules;
-//#endregion
-export { ModuleLoader as n, loadModules as r, LoadedModules as t };

package/dist/stub-loader/index.d.mts

@@ -1,2 +0,0 @@
-import { n as moduleConfigLoader } from "../index-BoAL29Di.mjs";
-export { moduleConfigLoader as default };

package/dist/stub-loader/index.mjs

@@ -1,31 +0,0 @@
-//#region src/stub-loader/interface.ts
-const loadConfig = async (_) => {
-	console.warn(`[warn] Empty module configuration loaded. Override "@izumisy-tailor/omakase-modules/config/loader" to "./modules.ts" in tsconfig.json paths in your app`);
-	return { config: {} };
-};
-/**
-* `moduleConfigLoader` is an interface for loading module configurations.
-*
-* By default, it throws an error indicating that the loader needs to be overridden in tsconfig.json.
-* Users should provide their "modules.ts" that calls `loadModules` which implements the actual loading logic.
-*
-* @example
-* ```
-* {
-*   "compilerOptions": {
-*     // ...
-*     "paths": {
-*       "@izumisy-tailor/omakase-modules/config/loader": ["./modules.ts"],
-*     }
-*   }
-* }
-* ```
-*/
-const moduleConfigLoader = { loadConfig };
-
-//#endregion
-//#region src/stub-loader/index.ts
-var stub_loader_default = moduleConfigLoader;
-
-//#endregion
-export { stub_loader_default as default };