@izumisy-tailor/omakase-modules 0.2.0 → 0.4.0

package/docs/generated/builder/type-aliases/TablesFromNames.md

@@ -0,0 +1,28 @@
+[**@izumisy-tailor/omakase-modules**](../../README.md)
+
+***
+
+[@izumisy-tailor/omakase-modules](../../modules.md) / [builder](../README.md) / TablesFromNames
+
+# Type Alias: TablesFromNames\<T\>
+
+> **TablesFromNames**\<`T`\> = `{ [K in T[number]]: TailorDBType }`
+
+Defined in: [builder/helpers.ts:390](https://github.com/tailor-sandbox/omakase-modules/blob/c8d6563533665d8bb159b4602b5c906b40e938f2/packages/core/src/builder/helpers.ts#L390)
+
+Derives a tables type from a tableNames array.
+Use this to avoid manually defining a separate Tables type.
+
+## Type Parameters
+
+| Type Parameter |
+| ------ |
+| `T` *extends* readonly `string`[] |
+
+## Example
+
+```typescript
+export const tableNames = ["product", "category"] as const;
+type MyTables = TablesFromNames<typeof tableNames>;
+// Result: { product: TailorDBType; category: TailorDBType }
+```

package/docs/generated/config/README.md

@@ -0,0 +1,19 @@
+[**@izumisy-tailor/omakase-modules**](../README.md)
+
+***
+
+[@izumisy-tailor/omakase-modules](../modules.md) / config
+
+# config
+
+## Classes
+
+- [ModuleLoader](classes/ModuleLoader.md)
+
+## Type Aliases
+
+- [LoadedModules](type-aliases/LoadedModules.md)
+
+## Functions
+
+- [loadModules](functions/loadModules.md)

package/docs/generated/config/classes/ModuleLoader.md

@@ -0,0 +1,128 @@
+[**@izumisy-tailor/omakase-modules**](../../README.md)
+
+***
+
+[@izumisy-tailor/omakase-modules](../../modules.md) / [config](../README.md) / ModuleLoader
+
+# Class: ModuleLoader
+
+Defined in: [config/module-loader.ts:49](https://github.com/tailor-sandbox/omakase-modules/blob/c8d6563533665d8bb159b4602b5c906b40e938f2/packages/core/src/config/module-loader.ts#L49)
+
+Module loader for registering and configuring modules.
+
+The `ModuleLoader` is used within the [loadModules](../functions/loadModules.md) function to register
+configured modules. Modules can depend on each other, and the loader ensures
+proper dependency management.
+
+## Example
+
+```typescript
+import { loadModules } from "@izumisy-tailor/omakase-modules";
+import commerceModule from "omakase-module-commerce-core";
+import orderModule from "omakase-module-order";
+import inventoryModule from "omakase-module-inventory";
+
+export default loadModules((loader) => {
+  // Add a module without dependencies
+  const $commerce = loader.add(
+    commerceModule.configure({
+      config: {
+        dataModel: {
+          product: { docNumberPrefix: "PROD" },
+        },
+      },
+    })
+  );
+
+  // Add a module that depends on commerce
+  const $order = loader.add(
+    orderModule.configure({
+      config: { dataModel: {} },
+      dependencies: { commerce: $commerce },
+    })
+  );
+
+  // Add a module that depends on both commerce and order
+  loader.add(
+    inventoryModule.configure({
+      config: { dbNamespace: "main-db" },
+      dependencies: { commerce: $commerce, order: $order },
+    })
+  );
+
+  return loader;
+});
+```
+
+## Constructors
+
+### Constructor
+
+> **new ModuleLoader**(): `ModuleLoader`
+
+#### Returns
+
+`ModuleLoader`
+
+## Methods
+
+### add()
+
+> **add**\<`C`\>(`module`): [`ConfiguredModule`](../../builder/type-aliases/ConfiguredModule.md)\<`C`\>
+
+Defined in: [config/module-loader.ts:92](https://github.com/tailor-sandbox/omakase-modules/blob/c8d6563533665d8bb159b4602b5c906b40e938f2/packages/core/src/config/module-loader.ts#L92)
+
+Add a configured module to the loader.
+
+Returns the added module so it can be used as a dependency for other modules.
+This enables type-safe dependency wiring between modules.
+
+#### Type Parameters
+
+| Type Parameter |
+| ------ |
+| `C` *extends* `Record`\<`string`, `unknown`\> |
+
+#### Parameters
+
+| Parameter | Type | Description |
+| ------ | ------ | ------ |
+| `module` | [`ConfiguredModule`](../../builder/type-aliases/ConfiguredModule.md)\<`C`\> | A configured module created by calling `moduleDefinition.configure()` |
+
+#### Returns
+
+[`ConfiguredModule`](../../builder/type-aliases/ConfiguredModule.md)\<`C`\>
+
+The same configured module, to be used as a dependency for other modules
+
+#### Example
+
+```typescript
+loadModules((loader) => {
+  // Capture the returned value to use as a dependency
+  const $commerce = loader.add(
+    commerceModule.configure({
+      config: {
+        dataModel: {
+          product: {
+            docNumberPrefix: "PP-PROD",
+            customAttributes: {
+              customStatus: db.enum(["new", "used", "refurbished"]),
+            },
+          },
+        },
+      },
+    })
+  );
+
+  // Use the captured module as a dependency
+  loader.add(
+    orderModule.configure({
+      config: { dataModel: {} },
+      dependencies: { commerce: $commerce },
+    })
+  );
+
+  return loader;
+});
+```

package/docs/generated/config/functions/loadModules.md

@@ -0,0 +1,79 @@
+[**@izumisy-tailor/omakase-modules**](../../README.md)
+
+***
+
+[@izumisy-tailor/omakase-modules](../../modules.md) / [config](../README.md) / loadModules
+
+# Function: loadModules()
+
+> **loadModules**(`configurator`): [`LoadedModules`](../type-aliases/LoadedModules.md)
+
+Defined in: [config/module-loader.ts:277](https://github.com/tailor-sandbox/omakase-modules/blob/c8d6563533665d8bb159b4602b5c906b40e938f2/packages/core/src/config/module-loader.ts#L277)
+
+Load and configure modules for your Tailor application.
+
+This is the main entry point for setting up omakase modules. Use this function
+to register all modules your application needs, configure them with your settings,
+and wire up dependencies between modules.
+
+## Parameters
+
+| Parameter | Type | Description |
+| ------ | ------ | ------ |
+| `configurator` | (`loader`) => [`ModuleLoader`](../classes/ModuleLoader.md) | A function that receives a [ModuleLoader](../classes/ModuleLoader.md) and returns it after adding modules |
+
+## Returns
+
+[`LoadedModules`](../type-aliases/LoadedModules.md)
+
+A [LoadedModules](../type-aliases/LoadedModules.md) object containing all registered modules and utilities
+
+## Example
+
+```typescript
+// modules.ts - Define your module configuration
+import { loadModules } from "@izumisy-tailor/omakase-modules";
+import { db } from "@tailor-platform/sdk";
+import commerceModule from "omakase-module-commerce-core";
+import orderModule from "omakase-module-order";
+import inventoryModule from "omakase-module-inventory";
+
+export default loadModules((loader) => {
+  // Configure and add the commerce module
+  const $commerce = loader.add(
+    commerceModule.configure({
+      config: {
+        dataModel: {
+          product: {
+            docNumberPrefix: "PP-PROD",
+            customAttributes: {
+              customStatus: db.enum(["new", "used", "refurbished"]),
+            },
+          },
+        },
+      },
+    })
+  );
+
+  // Configure order module with commerce as a dependency
+  const $order = loader.add(
+    orderModule.configure({
+      config: { dataModel: {} },
+      dependencies: { commerce: $commerce },
+    })
+  );
+
+  // Configure inventory module with both dependencies
+  loader.add(
+    inventoryModule.configure({
+      config: {
+        dbNamespace: "main-db",
+        invantoryBootstrapBaseValue: 300,
+      },
+      dependencies: { commerce: $commerce, order: $order },
+    })
+  );
+
+  return loader;
+});
+```

package/docs/generated/config/sdk/README.md

@@ -0,0 +1,16 @@
+[**@izumisy-tailor/omakase-modules**](../../README.md)
+
+***
+
+[@izumisy-tailor/omakase-modules](../../modules.md) / config/sdk
+
+# config/sdk
+
+## Type Aliases
+
+- [GetModulesReferenceOptions](type-aliases/GetModulesReferenceOptions.md)
+
+## Functions
+
+- [getModulesReference](functions/getModulesReference.md)
+- [loadModuleForDev](functions/loadModuleForDev.md)

package/docs/generated/config/sdk/functions/getModulesReference.md

@@ -0,0 +1,81 @@
+[**@izumisy-tailor/omakase-modules**](../../../README.md)
+
+***
+
+[@izumisy-tailor/omakase-modules](../../../modules.md) / [config/sdk](../README.md) / getModulesReference
+
+# Function: getModulesReference()
+
+> **getModulesReference**(`loadedModules`, `options`): `Promise`\<\{ `executor`: `string`[]; `resolver`: `string`[]; `tailordb`: `string`[]; \}\>
+
+Defined in: [config/sdk/paths.ts:98](https://github.com/tailor-sandbox/omakase-modules/blob/c8d6563533665d8bb159b4602b5c906b40e938f2/packages/core/src/config/sdk/paths.ts#L98)
+
+Get file path patterns for modules to use in Tailor configuration.
+
+This function processes your loaded modules and returns glob patterns
+that can be spread into your `defineConfig`. It handles all the necessary
+setup to make module TailorDB types, resolvers, and executors available
+to Tailor's configuration system.
+
+## Parameters
+
+| Parameter | Type | Description |
+| ------ | ------ | ------ |
+| `loadedModules` | [`LoadedModules`](../../type-aliases/LoadedModules.md) | The result of calling `loadModules()` |
+| `options` | [`GetModulesReferenceOptions`](../type-aliases/GetModulesReferenceOptions.md) | Optional configuration for path resolution and logging |
+
+## Returns
+
+`Promise`\<\{ `executor`: `string`[]; `resolver`: `string`[]; `tailordb`: `string`[]; \}\>
+
+An object containing glob patterns for `tailordb`, `resolver`, and `executor` files
+
+## Examples
+
+```typescript
+// tailor.config.ts
+import { defineConfig, defineGenerators } from "@tailor-platform/sdk";
+import { getModulesReference } from "@izumisy-tailor/omakase-modules/config/sdk";
+import modules from "./modules";
+
+// Get module path patterns
+const moduleReference = await getModulesReference(modules);
+
+export default defineConfig({
+  name: "my-app",
+
+  // Spread module paths alongside your local files
+  db: {
+    "main-db": {
+      files: ["./src/tailordb/*.ts", ...moduleReference.tailordb],
+    },
+  },
+
+  resolver: {
+    "main-pipeline": {
+      files: ["./src/resolvers/*.ts", ...moduleReference.resolver],
+    },
+  },
+
+  executor: {
+    files: ["./src/executors/*.ts", ...moduleReference.executor],
+  },
+});
+```
+
+```typescript
+// With custom options
+const moduleReference = await getModulesReference(modules, {
+  basePath: import.meta.dirname, // Use ESM module directory
+  silent: true, // No console output
+});
+```
+
+## Remarks
+
+The returned object contains three arrays:
+- `tailordb` - Paths to TailorDB type definitions from modules
+- `resolver` - Paths to GraphQL resolver definitions from modules
+- `executor` - Paths to event executor definitions from modules
+
+If a module has no files of a certain type, that array will be empty.

package/docs/generated/config/sdk/functions/loadModuleForDev.md

@@ -0,0 +1,53 @@
+[**@izumisy-tailor/omakase-modules**](../../../README.md)
+
+***
+
+[@izumisy-tailor/omakase-modules](../../../modules.md) / [config/sdk](../README.md) / loadModuleForDev
+
+# Function: loadModuleForDev()
+
+> **loadModuleForDev**\<`C`, `Tables`, `Deps`\>(`module`, `config?`): [`LoadedModules`](../../type-aliases/LoadedModules.md)
+
+Defined in: [config/sdk/dev-context.ts:29](https://github.com/tailor-sandbox/omakase-modules/blob/c8d6563533665d8bb159b4602b5c906b40e938f2/packages/core/src/config/sdk/dev-context.ts#L29)
+
+Creates a LoadedModules context for individual module development.
+
+This allows using `getModulesReference` in a module's own `tailor.config.ts`,
+enabling the kysely-type generator to work during module development.
+
+Dependencies declared in the module's `defineModule` are automatically
+registered with default (empty) configurations.
+
+## Type Parameters
+
+| Type Parameter |
+| ------ |
+| `C` *extends* `Record`\<`string`, `unknown`\> |
+| `Tables` *extends* `Record`\<`string`, `unknown`\> |
+| `Deps` *extends* [`DependencyModules`](../../../builder/type-aliases/DependencyModules.md) |
+
+## Parameters
+
+| Parameter | Type | Description |
+| ------ | ------ | ------ |
+| `module` | [`DefinedModule`](../../../builder/type-aliases/DefinedModule.md)\<`C`, `Tables`, `Deps`\> | The module being developed |
+| `config?` | `C` | Optional development configuration. If omitted, uses module.devConfig. |
+
+## Returns
+
+[`LoadedModules`](../../type-aliases/LoadedModules.md)
+
+A LoadedModules object that can be passed to getModulesReference
+
+## Example
+
+```typescript
+// tailor.config.ts
+import { loadModuleForDev, getModulesReference } from "@izumisy-tailor/omakase-modules/config/sdk";
+import inventoryModule from "./src/module";
+
+const modules = loadModuleForDev(inventoryModule);
+const moduleReference = await getModulesReference(modules);
+
+export default defineConfig({ ... });
+```

package/docs/generated/config/sdk/type-aliases/GetModulesReferenceOptions.md

@@ -0,0 +1,60 @@
+[**@izumisy-tailor/omakase-modules**](../../../README.md)
+
+***
+
+[@izumisy-tailor/omakase-modules](../../../modules.md) / [config/sdk](../README.md) / GetModulesReferenceOptions
+
+# Type Alias: GetModulesReferenceOptions
+
+> **GetModulesReferenceOptions** = `object`
+
+Defined in: [config/sdk/paths.ts:16](https://github.com/tailor-sandbox/omakase-modules/blob/c8d6563533665d8bb159b4602b5c906b40e938f2/packages/core/src/config/sdk/paths.ts#L16)
+
+Options for configuring [getModulesReference](../functions/getModulesReference.md) behavior.
+
+## Example
+
+```typescript
+const moduleReference = await getModulesReference(modules, {
+  basePath: "/custom/path",
+  silent: true, // Suppress console output
+});
+```
+
+## Properties
+
+### basePath?
+
+> `optional` **basePath**: `string`
+
+Defined in: [config/sdk/paths.ts:25](https://github.com/tailor-sandbox/omakase-modules/blob/c8d6563533665d8bb159b4602b5c906b40e938f2/packages/core/src/config/sdk/paths.ts#L25)
+
+Base path for the application.
+
+This determines where wrapper files are generated and where module
+paths are resolved from. Defaults to `process.cwd()`.
+
+#### Default
+
+```ts
+process.cwd()
+```
+
+***
+
+### silent?
+
+> `optional` **silent**: `boolean`
+
+Defined in: [config/sdk/paths.ts:34](https://github.com/tailor-sandbox/omakase-modules/blob/c8d6563533665d8bb159b4602b5c906b40e938f2/packages/core/src/config/sdk/paths.ts#L34)
+
+Whether to suppress log output.
+
+When `true`, no console output will be printed during module loading.
+Useful for testing or when you want cleaner build output.
+
+#### Default
+
+```ts
+false
+```

package/docs/generated/config/type-aliases/LoadedModules.md

@@ -0,0 +1,162 @@
+[**@izumisy-tailor/omakase-modules**](../../README.md)
+
+***
+
+[@izumisy-tailor/omakase-modules](../../modules.md) / [config](../README.md) / LoadedModules
+
+# Type Alias: LoadedModules
+
+> **LoadedModules** = `object`
+
+Defined in: [config/module-loader.ts:135](https://github.com/tailor-sandbox/omakase-modules/blob/c8d6563533665d8bb159b4602b5c906b40e938f2/packages/core/src/config/module-loader.ts#L135)
+
+The result of loading modules, providing access to module configurations and tables.
+
+This type is returned by [loadModules](../functions/loadModules.md) and passed to module factory functions.
+It provides utilities for:
+- Accessing configured module instances
+- Loading module configurations
+- Retrieving tables from dependency modules
+
+## Example
+
+```typescript
+// In tailor.config.ts - using getModulesReference with LoadedModules
+import { getModulesReference } from "@izumisy-tailor/omakase-modules/config/sdk";
+import modules from "./modules";
+
+const moduleReference = await getModulesReference(modules);
+
+export default defineConfig({
+  db: {
+    "main-db": {
+      files: ["./src/tailordb/*.ts", ...moduleReference.tailordb],
+    },
+  },
+  // ...
+});
+```
+
+## Properties
+
+### getTables()
+
+> **getTables**: \<`T`\>(`factory`) => `Promise`\<`T`\>
+
+Defined in: [config/module-loader.ts:204](https://github.com/tailor-sandbox/omakase-modules/blob/c8d6563533665d8bb159b4602b5c906b40e938f2/packages/core/src/config/module-loader.ts#L204)
+
+Get the tables from a dependency module by calling its factory function.
+
+Use this when a module needs to reference tables from another module,
+such as creating foreign key relationships or using shared types.
+
+#### Type Parameters
+
+| Type Parameter |
+| ------ |
+| `T` |
+
+#### Parameters
+
+| Parameter | Type | Description |
+| ------ | ------ | ------ |
+| `factory` | (`loadedModules`) => `Promise`\<`T`\> | The factory function exported by the dependency module's `tailordb/index.ts` |
+
+#### Returns
+
+`Promise`\<`T`\>
+
+A promise resolving to the tables created by the factory
+
+#### Example
+
+```typescript
+// In inventory-module's tailordb/index.ts
+import commerceModuleTables from "omakase-module-commerce-core/backend/tailordb";
+import orderModuleTables from "omakase-module-order/backend/tailordb";
+
+export default withModuleConfiguration(
+  moduleDef,
+  async (context, loadedModules) => {
+    // Get tables from commerce module to reference product/productVariant
+    const { product, productVariant } = await loadedModules.getTables(
+      commerceModuleTables
+    );
+
+    // Get tables from order module to reference order
+    const { order } = await loadedModules.getTables(orderModuleTables);
+
+    // Use dependency tables when building this module's tables
+    const inventory = buildInventoryTable(context, { product, productVariant });
+    const inventoryTransaction = buildInventoryTransactionTable(context, {
+      inventory,
+      order,
+    });
+
+    return { inventory, inventoryTransaction };
+  }
+);
+```
+
+***
+
+### loadConfig()
+
+> **loadConfig**: \<`C`\>(`module`) => `object`
+
+Defined in: [config/module-loader.ts:161](https://github.com/tailor-sandbox/omakase-modules/blob/c8d6563533665d8bb159b4602b5c906b40e938f2/packages/core/src/config/module-loader.ts#L161)
+
+Load the configuration for a specific module.
+
+Use this in module factory functions to access the user-provided configuration.
+Throws an error if the module has not been registered via `loadModules`.
+
+#### Type Parameters
+
+| Type Parameter |
+| ------ |
+| `C` *extends* `Record`\<`string`, `unknown`\> |
+
+#### Parameters
+
+| Parameter | Type | Description |
+| ------ | ------ | ------ |
+| `module` | \{ `packageName`: `string`; \} | An object with `packageName` (typically the module definition) |
+| `module.packageName` | `string` | - |
+
+#### Returns
+
+`object`
+
+An object containing the module's configuration
+
+##### config
+
+> **config**: `C`
+
+#### Throws
+
+Error if the module has not been configured
+
+#### Example
+
+```typescript
+// In a module's tailordb/index.ts
+import moduleDef from "../module";
+
+export default withModuleConfiguration(moduleDef, (context, loadedModules) => {
+  // Access this module's configuration
+  const { config } = loadedModules.loadConfig<ModuleConfig>(moduleDef);
+  const prefix = config.dataModel?.product?.docNumberPrefix ?? "PROD";
+
+  return { product: buildProductTable(context) };
+});
+```
+
+***
+
+### loadedModules
+
+> **loadedModules**: `Record`\<`string`, [`ConfiguredModule`](../../builder/type-aliases/ConfiguredModule.md)\<`any`\>\>
+
+Defined in: [config/module-loader.ts:136](https://github.com/tailor-sandbox/omakase-modules/blob/c8d6563533665d8bb159b4602b5c906b40e938f2/packages/core/src/config/module-loader.ts#L136)

package/docs/generated/modules.md

@@ -0,0 +1,11 @@
+[**@izumisy-tailor/omakase-modules**](README.md)
+
+***
+
+# @izumisy-tailor/omakase-modules
+
+## Modules
+
+- [builder](builder/README.md)
+- [config](config/README.md)
+- [config/sdk](config/sdk/README.md)