@izumisy-tailor/omakase-modules 0.3.0 → 0.4.1

package/README.md

@@ -29,19 +29,3 @@ pnpm add @izumisy-tailor/omakase-modules
 
 - [Using Modules](./docs/tutorials/using-modules.md) - How to use pre-built modules in your application
 - [Creating Modules](./docs/tutorials/creating-modules.md) - How to create reusable modules
-
-## API Reference
-
-### `@izumisy-tailor/omakase-modules`
-
-- `loadModules(configurator)` - Load and configure modules in your application
-
-### `@izumisy-tailor/omakase-modules/builder`
-
-- `defineModule<Config, Tables>(options)` - Define a new module
-- `withModuleConfiguration(module, factory)` - Access module configuration in TailorDB, Resolvers, and Executors
-- `ModuleDependency<T>` - Type utility for declaring module dependencies
-
-### `@izumisy-tailor/omakase-modules/config/sdk`
-
-- `getModulesReference(loadedModules)` - Generate file path references for `tailor.config.ts`

package/docs/generated/README.md

@@ -0,0 +1,35 @@
+**@izumisy-tailor/omakase-modules**
+
+***
+
+# Omakase Modules
+
+A **configurable module system** for Tailor Platform. Define reusable modules with type-safe configurations and share them across applications.
+
+## Motivation
+
+When building applications on Tailor Platform, you often face these challenges:
+
+1. **Reusability**: You want to reuse common data models and business logic (e.g., e-commerce, inventory, orders) across multiple applications
+2. **Customizability**: While modules should be reusable, you need to customize them for application-specific requirements
+3. **Dependency Management**: Module dependencies should be explicitly defined and managed in a type-safe manner
+
+Omakase Modules is designed to solve these challenges by providing a flexible, type-safe module system.
+
+## Key Features
+
+- **Module Definition**: Define modules with `defineModule` and declare type-safe configuration schemas
+- **Module Configuration**: Configure modules at the application level, injecting custom attributes and prefixes
+- **Dependency Management**: Explicitly define inter-module dependencies with the `ModuleDependency` type
+- **Configuration Injection**: Inject configurations into TailorDB, Resolvers, and Executors using `withModuleConfiguration`
+
+## Installation
+
+```bash
+pnpm add @izumisy-tailor/omakase-modules
+```
+
+## Documentation
+
+- [Using Modules](_media/using-modules.md) - How to use pre-built modules in your application
+- [Creating Modules](_media/creating-modules.md) - How to create reusable modules

package/docs/{tutorials → generated/_media}/creating-modules.md

@@ -22,9 +22,29 @@ my-module/
       my-executor.ts
 ```
 
+## Prerequisites: tsconfig.json Path Aliases
+
+Your module's `tsconfig.json` must include the following path aliases for the module system to function correctly:
+
+```jsonc
+{
+  "compilerOptions": {
+    "paths": {
+      "@omakase-modules/config": ["./src/module"],
+      "@/*": ["./src/*"]
+    }
+  }
+}
+```
+
+| Alias | Path | Purpose |
+|-------|------|---------|
+| `@omakase-modules/config` | `["./src/module"]` | **Required**. Points to your module definition file. The wrapper generator uses this alias to import your module's configuration during code generation. |
+| `@/*` | `["./src/*"]` | **Required**. Provides a shorthand for importing from the `src/` directory. Used internally during development mode to resolve local source files. |
+
 ## 1. Define the Module
 
-Create the module definition with `defineModule`:
+Create the module definition with `defineModule`. The module definition uses a builder pattern:
 
 ```typescript
 // src/module.ts
@@ -38,11 +58,19 @@ import * as pkg from "../package.json";
 
 export default defineModule<ModuleConfig, TablesFromNames<typeof tableNames>>({
   packageName: pkg.name,
-});
+})
+  .withDevConfig({})  // Optional: default config for development
+  .build();
 ```
 
 The `packageName` must match the `name` field in your `package.json`. The `TablesFromNames` utility type derives the table types from `tableNames`, ensuring they stay in sync.
 
+### Builder Methods
+
+- `.withDevConfig(config)` - Sets the default configuration used during module development
+- `.withDependencies(deps)` - Declares dependencies on other modules (see section 4)
+- `.build()` - Finalizes the module definition (must be called at the end)
+
 ## 2. Define Configuration Types
 
 Define what configuration options your module accepts:
@@ -127,22 +155,31 @@ export const buildProductTable = (
 
 ## 4. Declare Dependencies on Other Modules
 
-If your module depends on other modules, use `ModuleDependency`:
+If your module depends on other modules, use `.withDependencies()` in your module definition:
 
 ```typescript
-// src/types.ts
-import type { ModuleDependency } from "@izumisy-tailor/omakase-modules/builder";
-import type commerceCoreModule from "omakase-module-commerce-core";
+// src/module.ts
+import {
+  defineModule,
+  type TablesFromNames,
+} from "@izumisy-tailor/omakase-modules/builder";
+import { ModuleConfig } from "./types";
+import { tableNames } from "./tailordb";
+import * as pkg from "../package.json";
+import commerceModule from "omakase-module-commerce-core";
+import orderModule from "omakase-module-order";
 
-export type ModuleConfig = {
-  dataModel?: { /* ... */ };
-  dependencies: {
-    commerce: ModuleDependency<typeof commerceCoreModule>;
-  };
-};
+export default defineModule<ModuleConfig, TablesFromNames<typeof tableNames>>({
+  packageName: pkg.name,
+})
+  .withDevConfig({
+    dbNamespace: "main-db",
+  })
+  .withDependencies({ commerce: commerceModule, order: orderModule })
+  .build();
 ```
 
-This ensures type-safe dependency injection when users configure your module.
+The dependency modules are passed directly to `.withDependencies()`. This ensures type-safe dependency injection when users configure your module.
 
 ### Using Dependency Tables in TailorDB
 
@@ -150,9 +187,22 @@ When your module needs to reference tables from dependency modules, use `loadedM
 
 ```typescript
 // src/tailordb/index.ts
-import { withModuleConfiguration } from "@izumisy-tailor/omakase-modules/builder";
+import {
+  withModuleConfiguration,
+  type TablesFromNames,
+} from "@izumisy-tailor/omakase-modules/builder";
 import moduleDef from "../module";
+import { buildInventoryTable } from "./inventory";
+import { buildInventoryTransactionTable } from "./inventory-transaction";
+import { buildStockAdjustmentTable } from "./stock-adjustment";
 import commerceModuleTables from "omakase-module-commerce-core/backend/tailordb";
+import orderModuleTables from "omakase-module-order/backend/tailordb";
+
+export const tableNames = [
+  "inventory",
+  "inventoryTransaction",
+  "stockAdjustment",
+] as const;
 
 export default withModuleConfiguration(
   moduleDef,
@@ -161,9 +211,22 @@ export default withModuleConfiguration(
     const { product, productVariant } = await loadedModules.getTables(
       commerceModuleTables
     );
+    const { order } = await loadedModules.getTables(orderModuleTables);
 
     const inventory = buildInventoryTable(context, { product, productVariant });
-    // ...
+    const inventoryTransaction = buildInventoryTransactionTable(context, {
+      inventory,
+      order,
+    });
+    const stockAdjustment = buildStockAdjustmentTable(context, {
+      inventory,
+    });
+
+    return {
+      inventory,
+      inventoryTransaction,
+      stockAdjustment,
+    } satisfies TablesFromNames<typeof tableNames>;
   }
 );
 ```
@@ -236,7 +299,119 @@ src/executors/
 
 This is because the Tailor SDK processes resolver and executor files individually, expecting each file to contain a single definition with a default export.
 
-## 5. Configure Package Exports
+## 5. Set Up tailor.config.ts for Module Development
+
+Every module needs a `tailor.config.ts` file for development. This file uses `loadModuleForDev` to resolve the module's factory functions into actual TailorDB table definitions, enabling the Tailor SDK's generator to produce Kysely type definitions.
+
+### Why tailor.config.ts is Required
+
+Omakase Modules use a factory pattern—tables are not defined directly but through `withModuleConfiguration` functions that receive configuration at runtime. The Tailor SDK's `@tailor-platform/kysely-type` generator needs concrete table definitions to generate TypeScript types.
+
+`loadModuleForDev` bridges this gap by:
+1. Resolving your module's factory functions with the `devConfig` you defined
+2. Automatically registering any dependency modules
+3. Producing actual TailorDB table definitions that the generator can process
+
+The generated Kysely types (`src/generated/tailordb.ts`) enable:
+- **Type-safe SQL queries** in your module's executors and resolvers
+- **Cross-module JOIN queries** when other modules depend on yours via the `getDB` function
+
+### Basic tailor.config.ts
+
+```typescript
+// tailor.config.ts
+import { defineConfig, defineGenerators } from "@tailor-platform/sdk";
+import {
+  loadModuleForDev,
+  getModulesReference,
+} from "@izumisy-tailor/omakase-modules/config/sdk";
+import myModule from "./src/module";
+
+const moduleReference = await getModulesReference(
+  loadModuleForDev(myModule)
+);
+
+export default defineConfig({
+  name: "my-module",
+
+  db: {
+    "main-db": {
+      files: [...moduleReference.tailordb],
+    },
+  },
+});
+
+export const generators = defineGenerators([
+  "@tailor-platform/kysely-type",
+  { distPath: "./src/generated/tailordb.ts" },
+]);
+```
+
+> **Note**: Resolvers and executors are not required in `tailor.config.ts` during module development. The primary purpose is to generate Kysely type definitions for type-safe database queries.
+
+### The Role of devConfig
+
+The `devConfig` you define in your module with `.withDevConfig()` is the default configuration used by `loadModuleForDev`. This allows the generator to produce type definitions without explicitly passing configuration each time.
+
+If your module doesn't require any configuration, you can omit `.withDevConfig()` entirely—`loadModuleForDev` will use an empty object `{}` as the default.
+
+```typescript
+// src/module.ts - module with configuration
+export default defineModule<ModuleConfig, TablesFromNames<typeof tableNames>>({
+  packageName: pkg.name,
+})
+  .withDevConfig({
+    // Default configuration for development
+    dataModel: {
+      product: { docNumberPrefix: "DEV" },
+    },
+  })
+  .build();
+
+// src/module.ts - module without configuration (withDevConfig can be omitted)
+export default defineModule<ModuleConfig, TablesFromNames<typeof tableNames>>({
+  packageName: pkg.name,
+}).build();
+```
+
+When `loadModuleForDev(myModule)` is called without a second argument, it uses this `devConfig` (or `{}` if not defined). You can override it by passing a custom config:
+
+```typescript
+// Use custom config instead of devConfig
+loadModuleForDev(myModule, {
+  dataModel: {
+    product: { docNumberPrefix: "TEST" },
+  },
+});
+```
+
+This flexibility is useful for:
+- **Multiple tailor.config.ts files**: When you need different configurations for different environments (e.g., testing vs development)
+- **Temporary overrides**: When you want to test with a different configuration without modifying `devConfig`
+- **CI/CD pipelines**: When configuration needs to be passed dynamically from environment variables
+
+### Handling Dependencies in Development
+
+When your module has dependencies declared with `.withDependencies()`, `loadModuleForDev` automatically registers all dependency modules with empty configurations. This allows the generator to produce types that include dependency tables, enabling JOIN queries across module boundaries.
+
+```typescript
+// Module with dependencies
+export default defineModule<ModuleConfig, TablesFromNames<typeof tableNames>>({
+  packageName: pkg.name,
+})
+  .withDependencies({ commerce: commerceModule })
+  .withDevConfig({ /* ... */ })
+  .build();
+
+// In tailor.config.ts - dependencies are auto-registered
+const moduleReference = await getModulesReference(
+  loadModuleForDev(myModule)  // commerceModule is automatically loaded with {}
+);
+```
+
+> **Note**: In development context, dependency modules are registered with empty configurations (`{}`). Actual configuration for dependencies is provided when your module is used in an application via `loadModules`.
+
+## 6. Configure Package Exports
 
 Set up your `package.json` to export the module files.
 
@@ -248,6 +423,7 @@ Set up your `package.json` to export the module files.
   "type": "module",
   "exports": {
     ".": "./src/module.ts",
+    "./db": "./src/db.ts",
     "./backend/tailordb": "./src/tailordb/index.ts",
     "./backend/resolvers/*": "./src/resolvers/*.ts",
     "./backend/executors/*": "./src/executors/*.ts"
@@ -289,7 +465,6 @@ The `@izumisy-tailor/omakase-modules/builder` package provides these utility typ
 |------|-------------|
 | `TablesFromNames<T>` | Derives a tables type from a `tableNames` array. `T` should be `typeof tableNames`. |
 | `ModuleFactoryContext<C>` | Context passed to table builder functions. `C` is your module's config type. |
-| `ModuleDependency<T>` | Type for declaring dependencies on other modules. `T` is the module's default export type. |
 
 ## Next Steps
 

package/docs/{tutorials → generated/_media}/using-modules.md

@@ -100,7 +100,7 @@ The wrapper generator creates files that:
 
 ## 4. Handle Module Dependencies
 
-When modules depend on other modules, you need to wire them together:
+When modules depend on other modules, you need to wire them together. The `loader.add()` method returns the configured module, which can then be passed as a dependency to other modules via the `dependencies` property:
 
 ```typescript
 // modules.ts
@@ -112,7 +112,7 @@ import inventoryModule from "omakase-module-inventory";
 
 export default loadModules((loader) => {
   // Add the base module first
-  const $commerce = loader.add(
+  const $ecommerceModule = loader.add(
     ecommerceCoreModule.configure({
       config: {
         dataModel: {
@@ -127,14 +127,13 @@ export default loadModules((loader) => {
     })
   );
 
-  // Pass the commerce module as a dependency
-  const $order = loader.add(
+  // Pass the commerce module as a dependency via the dependencies property
+  const $orderModule = loader.add(
     orderModule.configure({
       config: {
-        dependencies: {
-          commerce: $commerce,
-        },
+        dataModel: {},
       },
+      dependencies: { commerce: $ecommerceModule },
     })
   );
 
@@ -142,12 +141,10 @@ export default loadModules((loader) => {
   loader.add(
     inventoryModule.configure({
       config: {
-        dbNamespace: "main",
-        dependencies: {
-          commerce: $commerce,
-          order: $order,
-        },
+        dbNamespace: "main-db",
+        invantoryBootstrapBaseValue: 300,
       },
+      dependencies: { commerce: $ecommerceModule, order: $orderModule },
     })
   );
 
@@ -155,7 +152,7 @@ export default loadModules((loader) => {
 });
 ```
 
-The `loader.add()` method returns the configured module, which can then be passed as a dependency to other modules. This ensures type-safe dependency wiring.
+Note that dependencies are passed as a separate `dependencies` property alongside `config`, not nested inside `config`. This ensures type-safe dependency wiring.
 
 ## Common Configuration Options
 
@@ -198,11 +195,13 @@ Some modules have their own configuration options:
 
 ```typescript
 // Inventory module example
-config: {
-  dbNamespace: "main",  // Required: TailorDB namespace for this module
-  invantoryBootstrapBaseValue: 200,  // Module-specific option
-  dependencies: { /* ... */ },
-}
+inventoryModule.configure({
+  config: {
+    dbNamespace: "main",  // Required: TailorDB namespace for this module
+    invantoryBootstrapBaseValue: 200,  // Module-specific option
+  },
+  dependencies: { commerce: $ecommerceModule, order: $orderModule },
+})
 ```
 
 ## Troubleshooting

package/docs/generated/builder/README.md

@@ -0,0 +1,25 @@
+[**@izumisy-tailor/omakase-modules**](../README.md)
+
+***
+
+[@izumisy-tailor/omakase-modules](../modules.md) / builder
+
+# builder
+
+## Type Aliases
+
+- [AnyDefinedModule](type-aliases/AnyDefinedModule.md)
+- [ConfiguredDependencies](type-aliases/ConfiguredDependencies.md)
+- [ConfiguredModule](type-aliases/ConfiguredModule.md)
+- [DefinedModule](type-aliases/DefinedModule.md)
+- [DependencyModules](type-aliases/DependencyModules.md)
+- [EmptyDependencies](type-aliases/EmptyDependencies.md)
+- [ModuleBuilder](type-aliases/ModuleBuilder.md)
+- [ModuleBuilderProps](type-aliases/ModuleBuilderProps.md)
+- [ModuleFactoryContext](type-aliases/ModuleFactoryContext.md)
+- [TablesFromNames](type-aliases/TablesFromNames.md)
+
+## Functions
+
+- [defineModule](functions/defineModule.md)
+- [withModuleConfiguration](functions/withModuleConfiguration.md)

package/docs/generated/builder/functions/defineModule.md

@@ -0,0 +1,60 @@
+[**@izumisy-tailor/omakase-modules**](../../README.md)
+
+***
+
+[@izumisy-tailor/omakase-modules](../../modules.md) / [builder](../README.md) / defineModule
+
+# Function: defineModule()
+
+> **defineModule**\<`C`, `Tables`\>(`baseProps`): [`ModuleBuilder`](../type-aliases/ModuleBuilder.md)\<`C`, `Tables`\>
+
+Defined in: [builder/helpers.ts:341](https://github.com/tailor-sandbox/omakase-modules/blob/c8d6563533665d8bb159b4602b5c906b40e938f2/packages/core/src/builder/helpers.ts#L341)
+
+Defines a reusable module with optional dependencies on other modules.
+
+## Type Parameters
+
+| Type Parameter | Default type |
+| ------ | ------ |
+| `C` *extends* `Record`\<`string`, `unknown`\> | - |
+| `Tables` *extends* `Record`\<`string`, `unknown`\> | `Record`\<`string`, `unknown`\> |
+
+## Parameters
+
+| Parameter | Type |
+| ------ | ------ |
+| `baseProps` | \{ `packageName`: `string`; \} |
+| `baseProps.packageName` | `string` |
+
+## Returns
+
+[`ModuleBuilder`](../type-aliases/ModuleBuilder.md)\<`C`, `Tables`\>
+
+## Example
+
+```typescript
+// Module without dependencies
+export default defineModule<ModuleConfig, Tables>({
+  packageName: "my-module",
+}).build();
+
+// Module with dependencies - Deps type is automatically inferred
+import commerceModule from "omakase-module-commerce-core";
+import orderModule from "omakase-module-order";
+
+export default defineModule<ModuleConfig, Tables>({
+  packageName: "my-module",
+}).withDependencies({
+  commerce: commerceModule,
+  order: orderModule,
+}).build();
+
+// When configuring a module with dependencies, pass them as a record:
+inventoryModule.configure({
+  config: { dbNamespace: "main-db" },
+  dependencies: {
+    commerce: $commerceModule,
+    order: $orderModule,
+  },
+});
+```

package/docs/generated/builder/functions/withModuleConfiguration.md

@@ -0,0 +1,68 @@
+[**@izumisy-tailor/omakase-modules**](../../README.md)
+
+***
+
+[@izumisy-tailor/omakase-modules](../../modules.md) / [builder](../README.md) / withModuleConfiguration
+
+# Function: withModuleConfiguration()
+
+> **withModuleConfiguration**\<`C`, `Tables`, `Deps`, `Result`\>(`module`, `factory`): (`loadedModules`) => `Promise`\<`Result`\>
+
+Defined in: [builder/register.ts:31](https://github.com/tailor-sandbox/omakase-modules/blob/c8d6563533665d8bb159b4602b5c906b40e938f2/packages/core/src/builder/register.ts#L31)
+
+Define module exports that depend on configuration from loadModules.
+
+This function returns a factory function that takes LoadedModules as input
+and produces the configured exports. The wrapper files generated by
+getModulesReference will call this factory with the app's loadModules result.
+
+## Type Parameters
+
+| Type Parameter |
+| ------ |
+| `C` *extends* `Record`\<`string`, `unknown`\> |
+| `Tables` *extends* `Record`\<`string`, `unknown`\> |
+| `Deps` *extends* `Record`\<`string`, `any`\> |
+| `Result` |
+
+## Parameters
+
+| Parameter | Type |
+| ------ | ------ |
+| `module` | [`DefinedModule`](../type-aliases/DefinedModule.md)\<`C`, `Tables`, `Deps`\> |
+| `factory` | (`context`, `loadedModules`) => `Result` \| `Promise`\<`Result`\> |
+
+## Returns
+
+> (`loadedModules`): `Promise`\<`Result`\>
+
+### Parameters
+
+| Parameter | Type |
+| ------ | ------ |
+| `loadedModules` | [`LoadedModules`](../../config/type-aliases/LoadedModules.md) |
+
+### Returns
+
+`Promise`\<`Result`\>
+
+## Example
+
+```typescript
+// In module's tailordb/index.ts
+export default withModuleConfiguration(moduleDef, (context) => {
+  const inventory = buildInventoryTable(context);
+  return { inventory };
+});
+
+// In module's executors that need dependency module tables:
+export default withModuleConfiguration(moduleDef, async (context, loadedModules) => {
+  const { productVariant } = await loadedModules.getTables(commerceModuleTables);
+  return createExecutor({ ... });
+});
+
+// The wrapper file will call it like:
+// import factory from "module/backend/tailordb";
+// import modules from "../../modules";
+// export default await factory(modules);
+```

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

@@ -0,0 +1,57 @@
+[**@izumisy-tailor/omakase-modules**](../../README.md)
+
+***
+
+[@izumisy-tailor/omakase-modules](../../modules.md) / [builder](../README.md) / AnyDefinedModule
+
+# Type Alias: AnyDefinedModule
+
+> **AnyDefinedModule** = `object`
+
+Defined in: [builder/helpers.ts:127](https://github.com/tailor-sandbox/omakase-modules/blob/c8d6563533665d8bb159b4602b5c906b40e938f2/packages/core/src/builder/helpers.ts#L127)
+
+A loosely-typed representation of any defined module.
+
+This type is used in dependency records where the exact type parameters
+of the module are not important. It provides the minimal interface needed
+to work with modules as dependencies.
+
+For strongly-typed module definitions, use [DefinedModule](DefinedModule.md) instead.
+
+## See
+
+[DefinedModule](DefinedModule.md) for the fully-typed module definition.
+
+## Properties
+
+### configure()
+
+> **configure**: (`props`) => [`ConfiguredModule`](ConfiguredModule.md)\<`any`\>
+
+Defined in: [builder/helpers.ts:130](https://github.com/tailor-sandbox/omakase-modules/blob/c8d6563533665d8bb159b4602b5c906b40e938f2/packages/core/src/builder/helpers.ts#L130)
+
+#### Parameters
+
+| Parameter | Type |
+| ------ | ------ |
+| `props` | `any` |
+
+#### Returns
+
+[`ConfiguredModule`](ConfiguredModule.md)\<`any`\>
+
+***
+
+### dependencies
+
+> **dependencies**: `Record`\<`string`, `any`\>
+
+Defined in: [builder/helpers.ts:129](https://github.com/tailor-sandbox/omakase-modules/blob/c8d6563533665d8bb159b4602b5c906b40e938f2/packages/core/src/builder/helpers.ts#L129)
+
+***
+
+### packageName
+
+> **packageName**: `string`
+
+Defined in: [builder/helpers.ts:128](https://github.com/tailor-sandbox/omakase-modules/blob/c8d6563533665d8bb159b4602b5c906b40e938f2/packages/core/src/builder/helpers.ts#L128)

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

@@ -0,0 +1,44 @@
+[**@izumisy-tailor/omakase-modules**](../../README.md)
+
+***
+
+[@izumisy-tailor/omakase-modules](../../modules.md) / [builder](../README.md) / ConfiguredDependencies
+
+# Type Alias: ConfiguredDependencies\<Deps\>
+
+> **ConfiguredDependencies**\<`Deps`\> = `{ [K in keyof Deps as K extends "__empty" ? never : K]: Deps[K] extends { __configBrand?: infer C } ? C extends Record<string, unknown> ? ConfiguredModule<C> : never : never }`
+
+Defined in: [builder/helpers.ts:170](https://github.com/tailor-sandbox/omakase-modules/blob/c8d6563533665d8bb159b4602b5c906b40e938f2/packages/core/src/builder/helpers.ts#L170)
+
+Transforms a record of [DefinedModule](DefinedModule.md)s into a record of [ConfiguredModule](ConfiguredModule.md)s.
+
+This utility type is used to derive the expected shape of the `dependencies`
+property when configuring a module that has dependencies. It preserves
+the exact configuration type for each dependency module.
+
+## Type Parameters
+
+| Type Parameter |
+| ------ |
+| `Deps` *extends* [`DependencyModules`](DependencyModules.md) |
+
+## Example
+
+```typescript
+// When a module is defined with dependencies:
+defineModule<MyConfig, MyTables>({
+  packageName: "my-module",
+}).withDependencies({
+  commerce: commerceModule,
+  order: orderModule,
+}).build();
+
+// The configure() method will expect:
+myModule.configure({
+  config: { ... },
+  dependencies: {
+    commerce: ConfiguredModule<CommerceConfig>,
+    order: ConfiguredModule<OrderConfig>,
+  },
+});
+```