@tailor-platform/erp-kit 0.1.2 → 0.2.1

package/src/generator/generate-code.ts

@@ -0,0 +1,260 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parseCommandDoc, errorCodeToClassName, type ParsedCommandDoc } from "./parse-command-doc";
+
+export function generateErrors(docs: ParsedCommandDoc[]): string {
+  const seen = new Set<string>();
+  const lines: string[] = [];
+
+  for (const doc of docs) {
+    for (const error of doc.errors) {
+      if (seen.has(error.code)) continue;
+      seen.add(error.code);
+
+      const className = errorCodeToClassName(error.code);
+      lines.push(`export const ${className} = createDomainError(`);
+      lines.push(`  "${className}", "${error.code}",`);
+      const escapedDesc = error.description.replace(/`/g, "'");
+      lines.push(`  (identifier: string) => \`${escapedDesc}: \${identifier}\`,`);
+      lines.push(`);`);
+      lines.push(``);
+    }
+  }
+
+  if (lines.length === 0) return "";
+
+  return `// @generated — do not edit
+import { createDomainError } from "../../shared/internal";
+
+${lines.join("\n")}`;
+}
+
+export function generateCommandStub(doc: ParsedCommandDoc): string {
+  const pascal = doc.commandName.charAt(0).toUpperCase() + doc.commandName.slice(1);
+  const inputType = `${pascal}Input`;
+
+  return `import { ok, type CommandContext } from "../../shared/internal";
+import type { DB } from "../generated/kysely-tailordb";
+
+export interface ${inputType} {
+  // TODO: define input fields
+}
+
+export async function run(db: DB, input: ${inputType}, ctx: CommandContext) {
+  // TODO: implement
+  return ok({});
+}
+`;
+}
+
+export function generateTestStub(doc: ParsedCommandDoc): string {
+  const pascal = doc.commandName.charAt(0).toUpperCase() + doc.commandName.slice(1);
+
+  return `import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../testing/index";
+import type { CommandContext } from "../../shared/internal";
+import type { DB } from "../generated/kysely-tailordb";
+import { run, ${pascal}Input } from "./${doc.commandName}";
+
+describe("${doc.commandName} - test scenario", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["TODO:${doc.commandName}"],
+  };
+
+  it("should be implemented", async () => {
+    const { db } = createMockDb<DB>();
+    const result = await run(db, {} as ${pascal}Input, ctx);
+    expect(result.ok).toBe(true);
+  });
+});
+`;
+}
+
+export function generateCommandShell(doc: ParsedCommandDoc): string {
+  const lines: string[] = [
+    `// @generated — do not edit`,
+    `import { defineCommand } from "../../shared/internal";`,
+    `import { permissions } from "../lib/permissions.generated";`,
+    `import { run } from "./${doc.commandName}";`,
+    ``,
+    `export const ${doc.commandName} = defineCommand(permissions.${doc.commandName}, run);`,
+    ``,
+  ];
+
+  return lines.join("\n");
+}
+
+export function generateQueryShell(doc: ParsedCommandDoc): string {
+  const lines: string[] = [
+    `// @generated — do not edit`,
+    `import { defineQuery } from "../../shared/internal";`,
+    `import { run } from "./${doc.commandName}";`,
+    ``,
+    `export const ${doc.commandName} = defineQuery(run);`,
+    ``,
+  ];
+
+  return lines.join("\n");
+}
+
+export function generateQueryStub(doc: ParsedCommandDoc): string {
+  const pascal = doc.commandName.charAt(0).toUpperCase() + doc.commandName.slice(1);
+  const inputType = `${pascal}Input`;
+
+  return `import type { ReadonlyDB } from "../../shared/internal";
+import type { DB } from "../generated/kysely-tailordb";
+
+export interface ${inputType} {
+  // TODO: define input fields
+}
+
+export async function run(db: ReadonlyDB<DB>, input: ${inputType}) {
+  // TODO: implement
+  return {};
+}
+`;
+}
+
+export function generateQueryTestStub(doc: ParsedCommandDoc): string {
+  const pascal = doc.commandName.charAt(0).toUpperCase() + doc.commandName.slice(1);
+  const inputType = `${pascal}Input`;
+
+  return `import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { run, type ${inputType} } from "./${doc.commandName}";
+
+describe("${doc.commandName}", () => {
+  it("should be implemented", async () => {
+    const { db } = createMockDb<DB>();
+    const result = await run(db, {} as ${inputType});
+    expect(result).toBeDefined();
+  });
+});
+`;
+}
+
+export function generatePermissions(moduleName: string, commandNames: string[]): string {
+  const sorted = [...commandNames].sort();
+  const entries = sorted.map((name) => `  "${name}",`).join("\n");
+
+  return `// @generated — do not edit
+import { definePermissions } from "../../shared/internal";
+
+export const { permissions, own, all } = definePermissions("${moduleName}", [
+${entries}
+] as const);
+`;
+}
+
+export function runGenerateCode(modulePath: string, moduleName: string): number {
+  const docsDir = path.join(modulePath, "docs", "commands");
+  const libDir = path.join(modulePath, "lib");
+  const commandDir = path.join(modulePath, "command");
+
+  if (!fs.existsSync(docsDir)) {
+    console.error(`No docs/commands/ directory found at ${docsDir}`);
+    return 1;
+  }
+
+  const mdFiles = fs.readdirSync(docsDir).filter((f) => f.endsWith(".md"));
+  if (mdFiles.length === 0) {
+    console.error(`No command docs found in ${docsDir}`);
+    return 1;
+  }
+
+  const parsedDocs: ParsedCommandDoc[] = [];
+
+  for (const file of mdFiles) {
+    const content = fs.readFileSync(path.join(docsDir, file), "utf-8");
+    const name = path.basename(file, ".md");
+    parsedDocs.push(parseCommandDoc(name, content));
+  }
+
+  // Also parse query docs for error extraction
+  const queryDocsDir = path.join(modulePath, "docs", "queries");
+  const allDocsForErrors = [...parsedDocs];
+  if (fs.existsSync(queryDocsDir)) {
+    const queryFiles = fs.readdirSync(queryDocsDir).filter((f) => f.endsWith(".md"));
+    for (const file of queryFiles) {
+      const content = fs.readFileSync(path.join(queryDocsDir, file), "utf-8");
+      const name = path.basename(file, ".md");
+      allDocsForErrors.push(parseCommandDoc(name, content));
+    }
+  }
+
+  let generated = 0;
+
+  const errorsContent = generateErrors(allDocsForErrors);
+  if (errorsContent) {
+    fs.mkdirSync(libDir, { recursive: true });
+    const errorsFile = path.join(libDir, "errors.generated.ts");
+    fs.writeFileSync(errorsFile, errorsContent);
+    console.log(`  wrote ${path.relative(modulePath, errorsFile)}`);
+    generated++;
+  }
+
+  const commandNames = parsedDocs.map((d) => d.commandName);
+  const permissionsContent = generatePermissions(moduleName, commandNames);
+  const permissionsFile = path.join(libDir, "permissions.generated.ts");
+  fs.writeFileSync(permissionsFile, permissionsContent);
+  console.log(`  wrote ${path.relative(modulePath, permissionsFile)}`);
+  generated++;
+
+  fs.mkdirSync(commandDir, { recursive: true });
+  for (const doc of parsedDocs) {
+    const implFile = path.join(commandDir, `${doc.commandName}.ts`);
+    const shellContent = generateCommandShell(doc);
+    const shellFile = path.join(commandDir, `${doc.commandName}.generated.ts`);
+    fs.writeFileSync(shellFile, shellContent);
+    console.log(`  wrote ${path.relative(modulePath, shellFile)}`);
+    generated++;
+
+    if (!fs.existsSync(implFile)) {
+      fs.writeFileSync(implFile, generateCommandStub(doc));
+      console.log(`  scaffolded ${path.relative(modulePath, implFile)}`);
+    }
+
+    const testFile = path.join(commandDir, `${doc.commandName}.test.ts`);
+    if (!fs.existsSync(testFile)) {
+      fs.writeFileSync(testFile, generateTestStub(doc));
+      console.log(`  scaffolded ${path.relative(modulePath, testFile)}`);
+    }
+  }
+
+  // Generate query files from docs/queries/*.md
+  if (fs.existsSync(queryDocsDir)) {
+    const queryFiles = fs.readdirSync(queryDocsDir).filter((f) => f.endsWith(".md"));
+    if (queryFiles.length > 0) {
+      const queryDir = path.join(modulePath, "query");
+      fs.mkdirSync(queryDir, { recursive: true });
+
+      for (const file of queryFiles) {
+        const content = fs.readFileSync(path.join(queryDocsDir, file), "utf-8");
+        const name = path.basename(file, ".md");
+        const doc = parseCommandDoc(name, content);
+
+        const shellFile = path.join(queryDir, `${doc.commandName}.generated.ts`);
+        fs.writeFileSync(shellFile, generateQueryShell(doc));
+        console.log(`  wrote ${path.relative(modulePath, shellFile)}`);
+        generated++;
+
+        const implFile = path.join(queryDir, `${doc.commandName}.ts`);
+        if (!fs.existsSync(implFile)) {
+          fs.writeFileSync(implFile, generateQueryStub(doc));
+          console.log(`  scaffolded ${path.relative(modulePath, implFile)}`);
+        }
+
+        const testFile = path.join(queryDir, `${doc.commandName}.test.ts`);
+        if (!fs.existsSync(testFile)) {
+          fs.writeFileSync(testFile, generateQueryTestStub(doc));
+          console.log(`  scaffolded ${path.relative(modulePath, testFile)}`);
+        }
+      }
+    }
+  }
+
+  console.log(`Generated ${generated} file(s) for ${moduleName}`);
+  return 0;
+}

package/src/generator/parse-command-doc.test.ts

@@ -0,0 +1,159 @@
+import { describe, expect, it } from "vitest";
+import { parseCommandDoc, errorCodeToClassName } from "./parse-command-doc";
+
+describe("parseCommandDoc", () => {
+  it("extracts error codes and descriptions from Error Scenarios section", () => {
+    const markdown = `# CreateItem
+
+## Overview
+
+Creates a new item.
+
+## Business Rules
+
+- SKU must be unique
+
+## Process Flow
+
+\`\`\`mermaid
+flowchart TD
+    A[Start] --> B[End]
+\`\`\`
+
+## External Dependencies
+
+- [primitives::Unit](../../../primitives/docs/models/Unit.md) - Validates UoM
+
+## Error Scenarios
+
+- **DUPLICATE_SKU**: An item with the same SKU already exists
+- **DUPLICATE_BARCODE**: An item with the same barcode already exists
+- **UNIT_NOT_FOUND**: Referenced unit does not exist or is inactive
+`;
+
+    const result = parseCommandDoc("CreateItem", markdown);
+
+    expect(result.commandName).toBe("createItem");
+    expect(result.errors).toEqual([
+      { code: "DUPLICATE_SKU", description: "An item with the same SKU already exists" },
+      { code: "DUPLICATE_BARCODE", description: "An item with the same barcode already exists" },
+      { code: "UNIT_NOT_FOUND", description: "Referenced unit does not exist or is inactive" },
+    ]);
+    expect(result.externalDependencies).toEqual([{ module: "primitives", entity: "Unit" }]);
+  });
+
+  it("handles command doc with no external dependencies", () => {
+    const markdown = `# CreateUser
+
+## Overview
+
+Creates a new user.
+
+## Business Rules
+
+- Email must be unique
+
+## Process Flow
+
+\`\`\`mermaid
+flowchart TD
+    A[Start] --> B[End]
+\`\`\`
+
+## External Dependencies
+
+- None
+
+## Error Scenarios
+
+- **USER_ALREADY_EXISTS**: User with this email already exists
+- **INVALID_EMAIL**: Invalid email format
+`;
+
+    const result = parseCommandDoc("CreateUser", markdown);
+
+    expect(result.commandName).toBe("createUser");
+    expect(result.externalDependencies).toEqual([]);
+    expect(result.errors).toHaveLength(2);
+  });
+
+  it("handles command doc without External Dependencies section", () => {
+    const markdown = `# ActivateItem
+
+## Overview
+
+Activates a draft item.
+
+## Business Rules
+
+- Item must be in DRAFT status
+
+## Process Flow
+
+\`\`\`mermaid
+flowchart TD
+    A[Start] --> B[End]
+\`\`\`
+
+## Error Scenarios
+
+- **ITEM_NOT_FOUND**: Item does not exist
+- **INVALID_STATE_TRANSITION**: Item is not in a valid state for activation
+`;
+
+    const result = parseCommandDoc("ActivateItem", markdown);
+
+    expect(result.commandName).toBe("activateItem");
+    expect(result.externalDependencies).toEqual([]);
+    expect(result.errors).toHaveLength(2);
+  });
+
+  it("extracts multiple external dependencies", () => {
+    const markdown = `# CreateOrder
+
+## Overview
+
+Creates an order.
+
+## Business Rules
+
+- Must reference valid item and customer
+
+## Process Flow
+
+\`\`\`mermaid
+flowchart TD
+    A[Start] --> B[End]
+\`\`\`
+
+## External Dependencies
+
+- [item-management::Item](../../../item-management/docs/models/Item.md) - Validates item
+- [primitives::Currency](../../../primitives/docs/models/Currency.md) - Validates currency
+
+## Error Scenarios
+
+- **ITEM_NOT_FOUND**: Referenced item does not exist
+`;
+
+    const result = parseCommandDoc("CreateOrder", markdown);
+
+    expect(result.externalDependencies).toEqual([
+      { module: "item-management", entity: "Item" },
+      { module: "primitives", entity: "Currency" },
+    ]);
+  });
+});
+
+describe("errorCodeToClassName", () => {
+  it("converts UPPER_SNAKE_CASE to PascalCase with Error suffix", () => {
+    expect(errorCodeToClassName("DUPLICATE_SKU")).toBe("DuplicateSkuError");
+    expect(errorCodeToClassName("UNIT_NOT_FOUND")).toBe("UnitNotFoundError");
+    expect(errorCodeToClassName("ITEM_NOT_FOUND")).toBe("ItemNotFoundError");
+    expect(errorCodeToClassName("USER_ALREADY_EXISTS")).toBe("UserAlreadyExistsError");
+  });
+
+  it("handles single word codes", () => {
+    expect(errorCodeToClassName("UNAUTHORIZED")).toBe("UnauthorizedError");
+  });
+});

package/src/generator/parse-command-doc.ts

@@ -0,0 +1,116 @@
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { toString } from "mdast-util-to-string";
+import type { Heading, List, Root, RootContent } from "mdast";
+
+export interface ParsedError {
+  code: string;
+  description: string;
+}
+
+export interface ParsedDependency {
+  module: string;
+  entity: string;
+}
+
+export interface ParsedCommandDoc {
+  commandName: string;
+  errors: ParsedError[];
+  externalDependencies: ParsedDependency[];
+}
+
+export function parseCommandDoc(fileName: string, markdown: string): ParsedCommandDoc {
+  const commandName = fileName.charAt(0).toLowerCase() + fileName.slice(1);
+  const tree = fromMarkdown(markdown);
+
+  return {
+    commandName,
+    errors: parseErrorScenarios(tree),
+    externalDependencies: parseExternalDependencies(tree),
+  };
+}
+
+export function errorCodeToClassName(code: string): string {
+  const pascal = code
+    .toLowerCase()
+    .split("_")
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join("");
+  return pascal + "Error";
+}
+
+function isHeading(node: RootContent): node is Heading {
+  return node.type === "heading";
+}
+
+function isList(node: RootContent): node is List {
+  return node.type === "list";
+}
+
+function getNodesUnderHeading(tree: Root, headingText: string): RootContent[] {
+  const nodes: RootContent[] = [];
+  let collecting = false;
+
+  for (const node of tree.children) {
+    if (isHeading(node)) {
+      if (collecting) break;
+      if (node.depth === 2 && toString(node) === headingText) {
+        collecting = true;
+        continue;
+      }
+    }
+    if (collecting) {
+      nodes.push(node);
+    }
+  }
+
+  return nodes;
+}
+
+const ERROR_PATTERN = /^([A-Z_]+):\s*(.+)$/;
+
+function parseErrorScenarios(tree: Root): ParsedError[] {
+  const nodes = getNodesUnderHeading(tree, "Error Scenarios");
+  const errors: ParsedError[] = [];
+
+  for (const node of nodes) {
+    if (!isList(node)) continue;
+
+    for (const item of node.children) {
+      const text = toString(item);
+      const match = ERROR_PATTERN.exec(text);
+      if (match) {
+        errors.push({ code: match[1], description: match[2].trim() });
+      }
+    }
+  }
+
+  return errors;
+}
+
+const DEPENDENCY_PATTERN = /^([^:]+)::(.+)$/;
+
+function parseExternalDependencies(tree: Root): ParsedDependency[] {
+  const nodes = getNodesUnderHeading(tree, "External Dependencies");
+  const deps: ParsedDependency[] = [];
+
+  for (const node of nodes) {
+    if (!isList(node)) continue;
+
+    for (const item of node.children) {
+      const firstChild = item.children[0];
+      if (firstChild?.type !== "paragraph") continue;
+
+      for (const inline of firstChild.children) {
+        if (inline.type === "link" || inline.type === "linkReference") {
+          const linkText = toString(inline);
+          const match = DEPENDENCY_PATTERN.exec(linkText);
+          if (match) {
+            deps.push({ module: match[1], entity: match[2] });
+          }
+        }
+      }
+    }
+  }
+
+  return deps;
+}

package/src/integration.test.ts

@@ -11,7 +11,7 @@ const REPO_ROOT = path.resolve(__dirname, "..", "..", "..");
 const skipReason = fs.existsSync(CLI_PATH) ? undefined : "Run `pnpm build` first";
 
 describe.skipIf(skipReason)("integration", () => {
-  it("module check command runs against sdk-plugins modules", () => {
+  it("module check command runs against erp-kit modules", () => {
     try {
       const result = execFileSync(
         "node",
@@ -31,7 +31,7 @@ describe.skipIf(skipReason)("integration", () => {
     }
   });
 
-  it("module sync-check command runs against sdk-plugins modules", () => {
+  it("module sync-check command runs against erp-kit modules", () => {
     try {
       const result = execFileSync(
         "node",

package/src/module.ts

@@ -19,9 +19,9 @@ export {
   permissions as primitivesPermissions,
   own as primitivesOwn,
   all as primitivesAll,
-} from "./modules/primitives/permissions";
+} from "./modules/primitives/lib/permissions.generated";
 export {
-  UoMCategoryNotFoundError,
+  UomCategoryNotFoundError,
   UnitNotFoundError,
   IncompatibleUnitsError,
   InactiveUnitError,
@@ -36,14 +36,14 @@ export {
   DuplicateCategoryNameError,
   CategoryHasActiveUnitsError,
   UnitNotInCategoryError,
-  InvalidISOCodeError,
+  InvalidIsoCodeError,
   DuplicateCurrencyCodeError,
   InvalidDecimalPlacesError,
   CannotDeactivateBaseCurrencyError,
   CannotSetInactiveAsBaseCurrencyError,
   SameCurrencyPairError,
   InvalidExchangeRateError,
-} from "./modules/primitives/lib/errors";
+} from "./modules/primitives/lib/errors.generated";
 export { type ConvertQuantityInput } from "./modules/primitives/query/convertQuantity";
 export { type ActivateCategoryInput } from "./modules/primitives/command/activateCategory";
 export { type DeactivateCategoryInput } from "./modules/primitives/command/deactivateCategory";
@@ -60,7 +60,7 @@ export {
   permissions as userManagementPermissions,
   own as userManagementOwn,
   all as userManagementAll,
-} from "./modules/user-management/permissions";
+} from "./modules/user-management/lib/permissions.generated";
 export { AuditEventEventType, UserStatus } from "./modules/user-management/generated/enums";
 export {
   UserNotFoundError,
@@ -76,7 +76,7 @@ export {
   DuplicateRoleNameError,
   AssignmentNotFoundError,
   InvalidEventTypeError,
-} from "./modules/user-management/lib/errors";
+} from "./modules/user-management/lib/errors.generated";
 export { type ActivateUserInput } from "./modules/user-management/command/activateUser";
 export { type DeactivateUserInput } from "./modules/user-management/command/deactivateUser";
 export { type ReactivateUserInput } from "./modules/user-management/command/reactivateUser";
@@ -85,3 +85,41 @@ export { type RevokePermissionFromRoleInput } from "./modules/user-management/co
 export { type AssignRoleToUserInput } from "./modules/user-management/command/assignRoleToUser";
 export { type RevokeRoleFromUserInput } from "./modules/user-management/command/revokeRoleFromUser";
 export { type LogAuditEventInput } from "./modules/user-management/command/logAuditEvent";
+// item-management
+export { defineModule as defineItemManagementModule } from "./modules/item-management/module";
+export {
+  permissions as itemManagementPermissions,
+  own as itemManagementOwn,
+  all as itemManagementAll,
+} from "./modules/item-management/lib/permissions.generated";
+export { ItemStatus } from "./modules/item-management/generated/enums";
+export {
+  ItemNotFoundError,
+  DuplicateSkuError,
+  DuplicateBarcodeError,
+  UnitNotFoundError as ItemUnitNotFoundError,
+  SkuImmutableError,
+  UomLockedError,
+  NoFieldsToUpdateError,
+  InvalidStateTransitionError,
+  DeleteNonDraftError,
+  NodeNotFoundError,
+  DuplicateNodeCodeError,
+  ParentNodeNotFoundError,
+  MaxDepthExceededError,
+  CodeImmutableError,
+  MissingRequiredFieldsError,
+  CircularReferenceError,
+  NodeHasChildrenError,
+  NodeHasAssignmentsError,
+  DuplicateAssignmentError,
+  AssignmentNotFoundError as ItemAssignmentNotFoundError,
+} from "./modules/item-management/lib/errors.generated";
+export { type GetItemInput } from "./modules/item-management/query/getItem";
+export { type GetTaxonomyNodeInput } from "./modules/item-management/query/getTaxonomyNode";
+export { type CreateItemInput } from "./modules/item-management/command/createItem";
+export { type UpdateItemInput } from "./modules/item-management/command/updateItem";
+export { type ActivateItemInput } from "./modules/item-management/command/activateItem";
+export { type DeactivateItemInput } from "./modules/item-management/command/deactivateItem";
+export { type CreateTaxonomyNodeInput } from "./modules/item-management/command/createTaxonomyNode";
+export { type AssignItemToTaxonomyInput } from "./modules/item-management/command/assignItemToTaxonomy";

package/src/modules/item-management/README.md

@@ -0,0 +1,38 @@
+# README
+
+## Overview
+
+The Item Management module manages items — the fundamental SKU-level entity in the ERP system. Items are the sellable, purchasable, and trackable unit that all downstream modules (Sales, Purchasing, Inventory, Manufacturing) reference as the primary transactional entity.
+
+Each item has its own lifecycle (DRAFT → ACTIVE ↔ INACTIVE), unique SKU identity, and optional barcode. Items are classified through a flexible taxonomy system (many-to-many with TaxonomyNode) for hierarchical browsing and filtering.
+
+## Key Features
+
+- **Item Lifecycle**: The canonical SKU-level entity referenced by all operational modules. Lifecycle state management (DRAFT → ACTIVE ↔ INACTIVE), SKU and barcode assignment. Items can be created directly or generated from product templates
+- **Item Taxonomy**: Hierarchical taxonomy tree for multi-dimensional item classification (many-to-many). Items can belong to multiple taxonomy branches simultaneously
+
+## Module Scope
+
+### In Scope
+
+- Item master data management (create, update, delete, status transitions)
+- Item lifecycle state machine (DRAFT → ACTIVE ↔ INACTIVE)
+- SKU and barcode assignment and uniqueness enforcement
+- Unit of measure assignment per item
+- Hierarchical item taxonomy management (TaxonomyNode tree)
+- Item-to-taxonomy classification (many-to-many)
+
+### Out of Scope
+
+- Product template definitions and attribute schemas (product-management module)
+- Variant generation from attribute combinations (product-management module)
+- Sales price list and pricing rule management (pricing module)
+- Inventory tracking and stock levels (inventory module)
+- Lot and serial number management (inventory module)
+- Vendor/supplier management (supplier-management module)
+- Bill of Materials (manufacturing module)
+- Product images and digital asset management
+
+## Module Dependencies
+
+- [primitives](../primitives/README.md) — UoM definitions for item unit of measure

package/src/modules/item-management/command/activateItem.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { defineCommand } from "../../shared/internal";
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./activateItem";
+
+export const activateItem = defineCommand(permissions.activateItem, run);