@tailor-platform/erp-kit 0.1.2 → 0.2.0

package/src/modules/user-management/generated/kysely-tailordb.ts

@@ -1,40 +1,28 @@
 import {
-  type ColumnType,
-  Kysely,
-  type KyselyConfig,
-  type Transaction as KyselyTransaction,
-  type Insertable as KyselyInsertable,
-  type Selectable as KyselySelectable,
-  type Updateable as KyselyUpdateable,
-} from "kysely";
-import { TailordbDialect } from "@tailor-platform/function-kysely-tailordb";
-
-type Timestamp = ColumnType<Date, Date | string, Date | string>;
-type Generated<T> =
-  T extends ColumnType<infer S, infer I, infer U>
-    ? ColumnType<S, I | undefined, U>
-    : ColumnType<T, T | undefined, T>;
+  createGetDB,
+  type Generated,
+  type Timestamp,
+  type NamespaceDB,
+  type NamespaceInsertable,
+  type NamespaceSelectable,
+  type NamespaceTable,
+  type NamespaceTableName,
+  type NamespaceTransaction,
+  type NamespaceUpdateable,
+} from "@tailor-platform/sdk/kysely";
 
 export interface Namespace {
   "main-db": {
     AuditEvent: {
       id: Generated<string>;
-      eventType:
-        | "USER_CREATED"
-        | "USER_ACTIVATED"
-        | "USER_DEACTIVATED"
-        | "USER_REACTIVATED"
-        | "ROLE_ASSIGNED"
-        | "ROLE_REVOKED"
-        | "PERMISSION_ASSIGNED"
-        | "PERMISSION_REVOKED";
+      eventType: "USER_CREATED" | "USER_ACTIVATED" | "USER_DEACTIVATED" | "USER_REACTIVATED" | "ROLE_ASSIGNED" | "ROLE_REVOKED" | "PERMISSION_ASSIGNED" | "PERMISSION_REVOKED";
       actorId: string;
       targetId: string | null;
       targetType: string | null;
       payload: string | null;
       createdAt: Generated<Timestamp>;
       updatedAt: Timestamp | null;
-    };
+    }
 
     Permission: {
       id: Generated<string>;
@@ -42,7 +30,7 @@ export interface Namespace {
       description: string | null;
       createdAt: Generated<Timestamp>;
       updatedAt: Timestamp | null;
-    };
+    }
 
     Role: {
       id: Generated<string>;
@@ -50,7 +38,7 @@ export interface Namespace {
       description: string | null;
       createdAt: Generated<Timestamp>;
       updatedAt: Timestamp | null;
-    };
+    }
 
     RolePermission: {
       id: Generated<string>;
@@ -58,7 +46,7 @@ export interface Namespace {
       permissionId: string;
       createdAt: Generated<Timestamp>;
       updatedAt: Timestamp | null;
-    };
+    }
 
     User: {
       id: Generated<string>;
@@ -68,7 +56,7 @@ export interface Namespace {
       permissions: string[] | null;
       createdAt: Generated<Timestamp>;
       updatedAt: Timestamp | null;
-    };
+    }
 
     UserRole: {
       id: Generated<string>;
@@ -76,37 +64,20 @@ export interface Namespace {
       roleId: string;
       createdAt: Generated<Timestamp>;
       updatedAt: Timestamp | null;
-    };
-  };
+    }
+  }
 }
 
-export function getDB<const N extends keyof Namespace>(
-  namespace: N,
-  kyselyConfig?: Omit<KyselyConfig, "dialect">,
-): Kysely<Namespace[N]> {
-  const client = new tailordb.Client({ namespace });
-  return new Kysely<Namespace[N]>({
-    dialect: new TailordbDialect(client),
-    ...kyselyConfig,
-  });
-}
+export const getDB = createGetDB<Namespace>();
 
-export type DB<N extends keyof Namespace = keyof Namespace> = ReturnType<typeof getDB<N>>;
+export type DB<N extends keyof Namespace = keyof Namespace> = NamespaceDB<Namespace, N>;
 
 export type Transaction<K extends keyof Namespace | DB = keyof Namespace> =
-  K extends DB<infer N>
-    ? KyselyTransaction<Namespace[N]>
-    : K extends keyof Namespace
-      ? KyselyTransaction<Namespace[K]>
-      : never;
+  NamespaceTransaction<Namespace, K>;
 
-type TableName = {
-  [N in keyof Namespace]: keyof Namespace[N];
-}[keyof Namespace];
-export type Table<T extends TableName> = {
-  [N in keyof Namespace]: T extends keyof Namespace[N] ? Namespace[N][T] : never;
-}[keyof Namespace];
+type TableName = NamespaceTableName<Namespace>;
+export type Table<T extends TableName> = NamespaceTable<Namespace, T>;
 
-export type Insertable<T extends keyof Namespace[keyof Namespace]> = KyselyInsertable<Table<T>>;
-export type Selectable<T extends keyof Namespace[keyof Namespace]> = KyselySelectable<Table<T>>;
-export type Updateable<T extends keyof Namespace[keyof Namespace]> = KyselyUpdateable<Table<T>>;
+export type Insertable<T extends TableName> = NamespaceInsertable<Namespace, T>;
+export type Selectable<T extends TableName> = NamespaceSelectable<Namespace, T>;
+export type Updateable<T extends TableName> = NamespaceUpdateable<Namespace, T>;

package/src/modules/user-management/index.ts

@@ -1,5 +1,5 @@
 export { defineModule } from "./module";
-export { permissions, own, all } from "./permissions";
+export { permissions, own, all } from "./lib/permissions.generated";
 
 // generated types
 export { AuditEventEventType, UserStatus } from "./generated/enums";
@@ -19,7 +19,7 @@ export {
   DuplicateRoleNameError,
   AssignmentNotFoundError,
   InvalidEventTypeError,
-} from "./lib/errors";
+} from "./lib/errors.generated";
 
 // input types
 export { type ActivateUserInput } from "./command/activateUser";

package/src/modules/user-management/lib/errors.generated.ts

@@ -0,0 +1,67 @@
+// @generated — do not edit
+import { createDomainError } from "../../shared/internal";
+
+export const UserNotFoundError = createDomainError(
+  "UserNotFoundError", "USER_NOT_FOUND",
+  (identifier: string) => `User ID does not exist in the system - return not found error with the provided ID: ${identifier}`,
+);
+
+export const InvalidStatusTransitionError = createDomainError(
+  "InvalidStatusTransitionError", "INVALID_STATUS_TRANSITION",
+  (identifier: string) => `User is not in PENDING status (already ACTIVE or INACTIVE) - return error with current status and valid transitions: ${identifier}`,
+);
+
+export const RoleNotFoundError = createDomainError(
+  "RoleNotFoundError", "ROLE_NOT_FOUND",
+  (identifier: string) => `Role ID does not exist in the system - return not found error with the provided role ID: ${identifier}`,
+);
+
+export const PermissionNotFoundError = createDomainError(
+  "PermissionNotFoundError", "PERMISSION_NOT_FOUND",
+  (identifier: string) => `Permission ID does not exist in the system - return not found error with the provided permission ID: ${identifier}`,
+);
+
+export const UserNotActiveError = createDomainError(
+  "UserNotActiveError", "USER_NOT_ACTIVE",
+  (identifier: string) => `User is in PENDING or INACTIVE status - return error indicating only ACTIVE users can receive role assignments: ${identifier}`,
+);
+
+export const InvalidPermissionKeyFormatError = createDomainError(
+  "InvalidPermissionKeyFormatError", "INVALID_PERMISSION_KEY_FORMAT",
+  (identifier: string) => `Key does not match resource:action pattern: ${identifier}`,
+);
+
+export const DuplicatePermissionKeyError = createDomainError(
+  "DuplicatePermissionKeyError", "DUPLICATE_PERMISSION_KEY",
+  (identifier: string) => `Permission with the same key already exists: ${identifier}`,
+);
+
+export const MissingRequiredFieldError = createDomainError(
+  "MissingRequiredFieldError", "MISSING_REQUIRED_FIELD",
+  (identifier: string) => `Role name not provided - return validation error indicating name is required: ${identifier}`,
+);
+
+export const DuplicateRoleNameError = createDomainError(
+  "DuplicateRoleNameError", "DUPLICATE_ROLE_NAME",
+  (identifier: string) => `Role with the same name already exists: ${identifier}`,
+);
+
+export const UserAlreadyExistsError = createDomainError(
+  "UserAlreadyExistsError", "USER_ALREADY_EXISTS",
+  (identifier: string) => `Email address is already registered in the system - return conflict error with message indicating email is taken: ${identifier}`,
+);
+
+export const InvalidEmailError = createDomainError(
+  "InvalidEmailError", "INVALID_EMAIL",
+  (identifier: string) => `Email does not follow valid email format - return validation error with format requirements: ${identifier}`,
+);
+
+export const InvalidEventTypeError = createDomainError(
+  "InvalidEventTypeError", "INVALID_EVENT_TYPE",
+  (identifier: string) => `Event type is not one of the recognized types - return validation error with list of valid event types: ${identifier}`,
+);
+
+export const AssignmentNotFoundError = createDomainError(
+  "AssignmentNotFoundError", "ASSIGNMENT_NOT_FOUND",
+  (identifier: string) => `Role does not have this permission assigned - return not found error indicating the association does not exist: ${identifier}`,
+);

package/src/modules/user-management/{permissions.ts → lib/permissions.generated.ts}

@@ -1,15 +1,16 @@
-import { definePermissions } from "../shared/internal";
+// @generated — do not edit
+import { definePermissions } from "../../shared/internal";
 
 export const { permissions, own, all } = definePermissions("user-management", [
-  "createUser",
   "activateUser",
-  "deactivateUser",
-  "reactivateUser",
+  "assignPermissionToRole",
+  "assignRoleToUser",
   "createPermission",
   "createRole",
-  "assignPermissionToRole",
+  "createUser",
+  "deactivateUser",
+  "logAuditEvent",
+  "reactivateUser",
   "revokePermissionFromRole",
-  "assignRoleToUser",
   "revokeRoleFromUser",
-  "logAuditEvent",
 ] as const);

package/src/modules/user-management/module.ts

@@ -1,16 +1,16 @@
 import { type TailorAnyDBField } from "@tailor-platform/sdk";
 import { type EmptyFields, type FieldsToInsertable } from "../shared/internal";
-import { makeCreateUser } from "./command/createUser";
-import { makeCreateRole } from "./command/createRole";
-import { makeCreatePermission } from "./command/createPermission";
-import { activateUser } from "./command/activateUser";
-import { deactivateUser } from "./command/deactivateUser";
-import { reactivateUser } from "./command/reactivateUser";
-import { assignPermissionToRole } from "./command/assignPermissionToRole";
-import { revokePermissionFromRole } from "./command/revokePermissionFromRole";
-import { assignRoleToUser } from "./command/assignRoleToUser";
-import { revokeRoleFromUser } from "./command/revokeRoleFromUser";
-import { logAuditEvent } from "./command/logAuditEvent";
+import { createUser } from "./command/createUser.generated";
+import { createRole } from "./command/createRole.generated";
+import { createPermission } from "./command/createPermission.generated";
+import { activateUser } from "./command/activateUser.generated";
+import { deactivateUser } from "./command/deactivateUser.generated";
+import { reactivateUser } from "./command/reactivateUser.generated";
+import { assignPermissionToRole } from "./command/assignPermissionToRole.generated";
+import { revokePermissionFromRole } from "./command/revokePermissionFromRole.generated";
+import { assignRoleToUser } from "./command/assignRoleToUser.generated";
+import { revokeRoleFromUser } from "./command/revokeRoleFromUser.generated";
+import { logAuditEvent } from "./command/logAuditEvent.generated";
 import { createAuditEventType, CreateAuditEventTypeParams } from "./db/auditEvent";
 import { createPermissionType, CreatePermissionTypeParams } from "./db/permission";
 import { createRoleType, CreateRoleTypeParams } from "./db/role";
@@ -61,17 +61,17 @@ export const defineModule = <
     db: { user, permission, role, userRole, rolePermission, auditEvent },
     executors: { rolePermissionCreated, rolePermissionDeleted },
     commands: {
-      createUser: makeCreateUser<FieldsToInsertable<UF>>(),
-      createRole: makeCreateRole<FieldsToInsertable<RF>>(),
-      createPermission: makeCreatePermission<FieldsToInsertable<PF>>(),
-      activateUser,
-      deactivateUser,
-      reactivateUser,
-      assignPermissionToRole,
-      revokePermissionFromRole,
-      assignRoleToUser,
-      revokeRoleFromUser,
-      logAuditEvent,
+      createUser: createUser<FieldsToInsertable<UF>>(),
+      createRole: createRole<FieldsToInsertable<RF>>(),
+      createPermission: createPermission<FieldsToInsertable<PF>>(),
+      activateUser: activateUser(),
+      deactivateUser: deactivateUser(),
+      reactivateUser: reactivateUser(),
+      assignPermissionToRole: assignPermissionToRole(),
+      revokePermissionFromRole: revokePermissionFromRole(),
+      assignRoleToUser: assignRoleToUser(),
+      revokeRoleFromUser: revokeRoleFromUser(),
+      logAuditEvent: logAuditEvent(),
     },
   };
 };

package/src/modules/user-management/tailor.config.ts

@@ -2,10 +2,10 @@ import { defineConfig, defineGenerators } from "@tailor-platform/sdk";
 
 export default defineConfig({
   name: "user-management",
-  db: { "main-db": { files: [`./src/db/*.ts`] } },
+  db: { "main-db": { files: [`./db/*.ts`] } },
 });
 
 export const generators = defineGenerators(
-  ["@tailor-platform/kysely-type", { distPath: `./src/generated/kysely-tailordb.ts` }],
-  ["@tailor-platform/enum-constants", { distPath: "./src/generated/enums.ts" }],
+  ["@tailor-platform/kysely-type", { distPath: `./generated/kysely-tailordb.ts` }],
+  ["@tailor-platform/enum-constants", { distPath: "./generated/enums.ts" }],
 );

package/src/schemas.ts

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { PACKAGE_ROOT } from "./util.js";
+import { PACKAGE_ROOT } from "./util";
 
 const SCHEMAS_ROOT = path.join(PACKAGE_ROOT, "schemas");
 

package/skills/1-module-docs/references/structure.md

@@ -1,22 +0,0 @@
-# Module Directory Structure
-
-```
-src/
-├── db/           # Database models (one file per model)
-├── executor/     # Async executors (record triggers, job functions)
-├── command/      # Domain commands + tests (*.test.ts co-located)
-├── lib/          # Internal shared code (errors.ts, types.ts)
-├── testing/      # Test fixtures and helpers
-├── generated/    # Auto-generated code (do not edit)
-├── index.ts      # Public exports
-└── module.ts     # Module definition
-```
-
-## Rules
-
-- `db/`: Only documentable model definitions, no helpers
-- `executor/`: Async executors as factory functions (see executors.md)
-- `command/`: Domain commands + co-located tests, no utilities
-- `lib/`: Internal errors and types (not documented)
-- `testing/`: Fixtures for tests only
-- Run `pnpm generate` after modifying `db/` models

package/skills/2-module-feature-breakdown/references/commands.md

@@ -1,48 +0,0 @@
-# Command Implementation
-
-## defineCommand Pattern
-
-Commands that don't need custom fields use `defineCommand` directly:
-
-```typescript
-export const myCommand = defineCommand(permissions.myCommand, async (db: DB, input: Input) => { ... });
-```
-
-## Factory Function Pattern (custom fields)
-
-Commands that insert into a table with user-extensible fields use a `makeCreateX<CF>()` factory:
-
-- Export only `makeCreateX` — no default instance
-- Generic `CF extends Record<string, unknown>` for custom fields
-- Input type: `CreateXInput & CF`
-- Destructure known fields, rest-spread custom fields into `.values()` before known fields
-- Cast custom fields: `...(customFields as Record<string, unknown>)`
-- `module.ts` wires with `makeCreateX<FieldsToInsertable<F>>()`
-
-## Implementation Considerations
-
-- **Validation**: Check referenced entities exist before operating
-- **Idempotency**: For assign/revoke, return existing instead of throwing
-- **Return format**: Wrap in object `{ entity }` not just `entity`
-
-## Conventions
-
-- Input types: exported interfaces (`export interface MyFunctionInput`)
-- Use `.executeTakeFirst()` for single results
-- Include JSDoc: `/** Function: name \n Description */`
-
-## State Transitions
-
-For commands that transition between statuses, accept `from?: string[]` with a default:
-
-```typescript
-from?: string[];  // Default: ["ACTIVE"]
-
-const validFromStatuses = input.from ?? ["ACTIVE"];
-if (!validFromStatuses.includes(user.status)) {
-  throw new InvalidStatusTransitionError(user.status, targetStatus);
-}
-```
-
-- Default `from` contains the base valid source status
-- Parent modules can override to allow transitions from additional statuses

package/skills/2-module-feature-breakdown/references/structure.md

@@ -1,22 +0,0 @@
-# Module Directory Structure
-
-```
-src/
-├── db/           # Database models (one file per model)
-├── executor/     # Async executors (record triggers, job functions)
-├── command/      # Domain commands + tests (*.test.ts co-located)
-├── lib/          # Internal shared code (errors.ts, types.ts)
-├── testing/      # Test fixtures and helpers
-├── generated/    # Auto-generated code (do not edit)
-├── index.ts      # Public exports
-└── module.ts     # Module definition
-```
-
-## Rules
-
-- `db/`: Only documentable model definitions, no helpers
-- `executor/`: Async executors as factory functions (see executors.md)
-- `command/`: Domain commands + co-located tests, no utilities
-- `lib/`: Internal errors and types (not documented)
-- `testing/`: Fixtures for tests only
-- Run `pnpm generate` after modifying `db/` models

package/skills/3-module-doc-review/references/commands.md

@@ -1,54 +0,0 @@
----
-paths:
-  - "packages/erp-kit/src/modules/*/command/*.ts"
-  - "!packages/erp-kit/src/modules/*/command/*.test.ts"
----
-
-# Command Implementation
-
-## defineCommand Pattern
-
-Commands that don't need custom fields use `defineCommand` directly:
-
-```typescript
-export const myCommand = defineCommand(permissions.myCommand, async (db: DB, input: Input) => { ... });
-```
-
-## Factory Function Pattern (custom fields)
-
-Commands that insert into a table with user-extensible fields use a `makeCreateX<CF>()` factory:
-
-- Export only `makeCreateX` — no default instance
-- Generic `CF extends Record<string, unknown>` for custom fields
-- Input type: `CreateXInput & CF`
-- Destructure known fields, rest-spread custom fields into `.values()` before known fields
-- Cast custom fields: `...(customFields as Record<string, unknown>)`
-- `module.ts` wires with `makeCreateX<FieldsToInsertable<F>>()`
-
-## Implementation Considerations
-
-- **Validation**: Check referenced entities exist before operating
-- **Idempotency**: For assign/revoke, return existing instead of throwing
-- **Return format**: Wrap in object `{ entity }` not just `entity`
-
-## Conventions
-
-- Input types: exported interfaces (`export interface MyFunctionInput`)
-- Use `.executeTakeFirst()` for single results
-- Include JSDoc: `/** Function: name \n Description */`
-
-## State Transitions
-
-For commands that transition between statuses, accept `from?: string[]` with a default:
-
-```typescript
-from?: string[];  // Default: ["ACTIVE"]
-
-const validFromStatuses = input.from ?? ["ACTIVE"];
-if (!validFromStatuses.includes(user.status)) {
-  throw new InvalidStatusTransitionError(user.status, targetStatus);
-}
-```
-
-- Default `from` contains the base valid source status
-- Parent modules can override to allow transitions from additional statuses

package/skills/3-module-doc-review/references/models.md

@@ -1,29 +0,0 @@
-# Database Models
-
-## Factory Function Pattern
-
-Each model is a `createXType<const F>(params)` factory:
-
-- Params interface generic: `F extends Record<string, TailorAnyDBField>`
-- `fields?: F` — optional custom fields from parent modules
-- Spread as `...(params.fields ?? {}) as F` to preserve type information
-- Include `...db.fields.timestamps()`
-- Use `.description()` for field docs
-- Apply permissions at model level
-- Export a default instance: `export const x = createXType({})`
-
-## Stateful Model Enums
-
-Status enums are tied to the module's state machine. Base module defines core statuses; parent callers can only **extend, not replace**.
-
-```typescript
-// Good: extension only
-const BASE_STATUSES = ["PENDING", "ACTIVE", "INACTIVE"] as const;
-const statuses = [...BASE_STATUSES, ...(params.additionalStatuses ?? [])];
-
-// Bad: allows replacement
-const statuses = params.statuses ?? ["PENDING", "ACTIVE", "INACTIVE"];
-```
-
-- Name parameter `additionalX` to signal extension-only
-- Parent modules handle their additional status transitions

package/skills/4-module-tdd-implementation/SKILL.md

@@ -1,74 +0,0 @@
----
-name: 4-module-tdd-implementation
-description: Use when implementing features in any module under modules/. Triggers on TDD workflow, domain command implementation, adding new database models, creating test fixtures, or implementing business logic commands.
----
-
-# TDD Implementation for Module Development
-
-Guide for implementing features in modules using Test-Driven Development.
-
-## When to Use
-
-- Implementing new domain commands in any module
-- Adding database models with `@tailor-platform/sdk`
-- Creating tests with `@tailor-platform/erp-kit` testing utilities
-- Implementing business logic (CRUD, state transitions, relationships)
-
-## Workflow
-
-```
-MODELS → ERRORS → FIXTURES → TESTS → IMPLEMENT → EXPORT → VERIFY
-```
-
-## Step-by-Step
-
-### 1. Database Models (`src/db/`)
-
-**Read [models rules](references/models.md) and [db-relations rules](references/db-relations.md) before writing any model.**
-
-Key patterns: factory function, `db.fields.timestamps()`, `.description()` on fields, `.relation()` for foreign keys.
-
-### 2. Error Classes (`src/lib/errors.ts`)
-
-**Read [errors rules](references/errors.md) before defining errors.**
-
-Key patterns: `name` as const = class name, `code` as const = SCREAMING_SNAKE_CASE.
-
-### 3. Test Fixtures (`src/testing/fixtures.ts`)
-
-**Read [testing rules](references/testing.md) before writing fixtures or tests.**
-
-### 4. Write Tests First (`src/command/*.test.ts`)
-
-Same reference: [testing rules](references/testing.md).
-
-Key patterns: `createMockDb<DB>()`, fixed IDs `"entity-1"`, cover all doc branches.
-
-### 5. Implement Commands (`src/command/*.ts`)
-
-**Read [commands rules](references/commands.md) before implementing.**
-
-Key patterns: dual function (`_fn` internal + `fn<T>` public), validate → query → mutate.
-
-### 6. Export (`src/index.ts`)
-
-**Read [exports rules](references/exports.md) for export order.**
-
-### 7. Verify
-
-```bash
-pnpm generate   # Regenerate types if models changed
-pnpm lint       # Check code style
-pnpm typecheck  # Verify TypeScript types
-pnpm test       # Run all tests
-```
-
-## References
-
-- [Module structure](references/structure.md)
-- [Model patterns](references/models.md)
-- [Database relations](references/db-relations.md)
-- [Command patterns](references/commands.md)
-- [Error patterns](references/errors.md)
-- [Testing patterns](references/testing.md)
-- [Export order](references/exports.md)

package/skills/4-module-tdd-implementation/references/commands.md

@@ -1,45 +0,0 @@
-# Command Implementation
-
-## Dual Function Pattern
-
-Two functions per operation: internal `_fn` and public `fn`.
-
-**Internal function (`_myFunction`):**
-
-- Takes concrete `DB` type from `generated/kysely-tailordb`
-- Return type uses `Schema` from `lib/types`: `Promise<{ entity: Entity<Schema> }>`
-- Contains actual implementation
-
-**Public function (`myFunction`):**
-
-- Generic signature: `<T extends { Entity: object }>(db: Kysely<T>, ...)`
-- Return type uses generic `T`: `Promise<{ entity: Entity<T> }>`
-- Delegates to internal with type casting: `_fn(db as unknown as DB, ...) as unknown as Result`
-
-## Implementation Considerations
-
-- **Validation**: Check referenced entities exist before operating
-- **Idempotency**: For assign/revoke, return existing instead of throwing
-- **Return format**: Wrap in object `{ entity }` not just `entity`
-
-## Conventions
-
-- Input types: exported interfaces (`export interface MyFunctionInput`)
-- Use `.executeTakeFirst()` for single results
-- Include JSDoc: `/** Function: name \n Description */`
-
-## State Transitions
-
-For commands that transition between statuses, accept `from?: string[]` with a default:
-
-```typescript
-from?: string[];  // Default: ["ACTIVE"]
-
-const validFromStatuses = input.from ?? ["ACTIVE"];
-if (!validFromStatuses.includes(user.status)) {
-  throw new InvalidStatusTransitionError(user.status, targetStatus);
-}
-```
-
-- Default `from` contains the base valid source status
-- Parent modules can override to allow transitions from additional statuses

package/skills/4-module-tdd-implementation/references/errors.md

@@ -1,7 +0,0 @@
-# Error Classes
-
-Naming convention:
-
-- `name`: Class name exactly, `as const`
-- `code`: SCREAMING_SNAKE_CASE, `as const`
-- Constructor includes context (IDs, values)

package/skills/4-module-tdd-implementation/references/models.md

@@ -1,30 +0,0 @@
-# Database Models
-
-## Factory Function Pattern
-
-```typescript
-export function createEntityType(params: {
-  fields?: Record<string, unknown>;
-  additionalStatuses?: string[];
-});
-```
-
-- Include `...db.fields.timestamps()`
-- Use `.description()` for field docs
-- Apply permissions at model level
-
-## Stateful Model Enums
-
-Status enums are tied to the module's state machine. Base module defines core statuses; parent callers can only **extend, not replace**.
-
-```typescript
-// Good: extension only
-const BASE_STATUSES = ["PENDING", "ACTIVE", "INACTIVE"] as const;
-const statuses = [...BASE_STATUSES, ...(params.additionalStatuses ?? [])];
-
-// Bad: allows replacement
-const statuses = params.statuses ?? ["PENDING", "ACTIVE", "INACTIVE"];
-```
-
-- Name parameter `additionalX` to signal extension-only
-- Parent modules handle their additional status transitions