@tailor-platform/erp-kit 0.0.1 → 0.1.0

package/src/commands/scaffold.ts

@@ -0,0 +1,119 @@
+import path from "node:path";
+import fs from "node:fs";
+import { runMdschema } from "../mdschema.js";
+import { ALL_SCHEMAS } from "../schemas.js";
+
+export const MODULE_TYPES = ["module", "feature", "command", "model"] as const;
+export const APP_TYPES = [
+  "requirements",
+  "actors",
+  "business-flow",
+  "story",
+  "screen",
+  "resolver",
+] as const;
+export const ALL_TYPES = [...MODULE_TYPES, ...APP_TYPES] as const;
+
+export type ScaffoldType = (typeof ALL_TYPES)[number];
+
+const MODULE_DIR_MAP: Record<string, string> = {
+  feature: "docs/features",
+  command: "docs/commands",
+  model: "docs/models",
+};
+
+const APP_DIR_MAP: Record<string, string> = {
+  actors: "docs/actors",
+  "business-flow": "docs/business-flow",
+  screen: "docs/screen",
+  resolver: "docs/resolver",
+};
+
+export function isModuleType(type: string): boolean {
+  return (MODULE_TYPES as readonly string[]).includes(type);
+}
+
+export function resolveScaffoldPath(
+  type: ScaffoldType,
+  parentName: string,
+  name: string | undefined,
+  root: string,
+): string {
+  // Types that map to README.md (no name needed)
+  if (type === "module" || type === "requirements") {
+    return path.join(root, parentName, "README.md");
+  }
+
+  if (!name) {
+    throw new Error(`Name is required for scaffold type "${type}"`);
+  }
+
+  // business-flow produces a README inside a named directory
+  if (type === "business-flow") {
+    return path.join(root, parentName, "docs/business-flow", name, "README.md");
+  }
+
+  // story accepts "flow/story-name" to place under the correct flow directory
+  if (type === "story") {
+    const parts = name.split("/");
+    if (parts.length !== 2) {
+      throw new Error(
+        `Story name must be "<flow>/<story>" (e.g., "onboarding/admin--create-user")`,
+      );
+    }
+    return path.join(root, parentName, "docs/business-flow", parts[0], "story", `${parts[1]}.md`);
+  }
+
+  // Module sub-types
+  if (MODULE_DIR_MAP[type]) {
+    return path.join(root, parentName, MODULE_DIR_MAP[type], `${name}.md`);
+  }
+
+  // App sub-types
+  if (APP_DIR_MAP[type]) {
+    return path.join(root, parentName, APP_DIR_MAP[type], `${name}.md`);
+  }
+
+  throw new Error(`Unknown scaffold type: ${type}`);
+}
+
+export async function runScaffold(
+  type: ScaffoldType,
+  parentName: string,
+  name: string | undefined,
+  root: string,
+  cwd: string,
+): Promise<number> {
+  const outputPath = resolveScaffoldPath(type, parentName, name, root);
+  const absoluteOutput = path.resolve(cwd, outputPath);
+
+  if (fs.existsSync(absoluteOutput)) {
+    console.error(`File already exists: ${outputPath}`);
+    return 1;
+  }
+
+  const schemaPath = ALL_SCHEMAS[type];
+  if (!schemaPath) {
+    console.error(`No schema found for type: ${type}`);
+    return 2;
+  }
+
+  try {
+    fs.mkdirSync(path.dirname(absoluteOutput), { recursive: true });
+  } catch (err) {
+    console.error(
+      `Failed to create directory: ${err instanceof Error ? err.message : String(err)}`,
+    );
+    return 1;
+  }
+
+  const { exitCode, stdout, stderr } = await runMdschema(
+    ["generate", "--schema", schemaPath, "--output", absoluteOutput],
+    cwd,
+  );
+
+  if (stdout.trim()) console.log(stdout);
+  if (stderr.trim()) console.error(stderr);
+
+  return exitCode;
+}

package/src/commands/sync-check.test.ts

@@ -0,0 +1,125 @@
+import path from "node:path";
+import os from "node:os";
+import fs from "node:fs";
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { runSyncCheck } from "./sync-check.js";
+
+describe("runSyncCheck", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sync-check-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("returns 0 for an empty directory with no sources or docs", async () => {
+    const result = await runSyncCheck({ modulesRoot: "modules", appRoot: "examples" }, tmpDir);
+    expect(result.exitCode).toBe(0);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it("reports missing doc when source exists without doc", async () => {
+    const srcDir = path.join(tmpDir, "modules", "foo", "command");
+    fs.mkdirSync(srcDir, { recursive: true });
+    fs.writeFileSync(path.join(srcDir, "createOrder.ts"), "export {}");
+
+    const result = await runSyncCheck({ modulesRoot: "modules", appRoot: "examples" }, tmpDir);
+    expect(result.exitCode).toBe(1);
+    expect(result.errors).toContainEqual(
+      expect.objectContaining({ type: "missing-doc", expectedBasename: "createorder" }),
+    );
+  });
+
+  it("reports orphaned doc when doc exists without source", async () => {
+    const docDir = path.join(tmpDir, "modules", "foo", "docs", "commands");
+    fs.mkdirSync(docDir, { recursive: true });
+    fs.writeFileSync(path.join(docDir, "createOrder.md"), "# CreateOrder");
+
+    const result = await runSyncCheck({ modulesRoot: "modules", appRoot: "examples" }, tmpDir);
+    expect(result.exitCode).toBe(1);
+    expect(result.errors).toContainEqual(
+      expect.objectContaining({ type: "orphaned-doc", expectedBasename: "createorder" }),
+    );
+  });
+
+  it("returns 0 when source and doc match", async () => {
+    const srcDir = path.join(tmpDir, "modules", "foo", "command");
+    const docDir = path.join(tmpDir, "modules", "foo", "docs", "commands");
+    fs.mkdirSync(srcDir, { recursive: true });
+    fs.mkdirSync(docDir, { recursive: true });
+    fs.writeFileSync(path.join(srcDir, "createOrder.ts"), "export {}");
+    fs.writeFileSync(path.join(docDir, "createOrder.md"), "# CreateOrder");
+
+    const result = await runSyncCheck({ modulesRoot: "modules", appRoot: "examples" }, tmpDir);
+    expect(result.exitCode).toBe(0);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it("excludes test files from source matching", async () => {
+    const srcDir = path.join(tmpDir, "modules", "foo", "command");
+    fs.mkdirSync(srcDir, { recursive: true });
+    fs.writeFileSync(path.join(srcDir, "createOrder.test.ts"), "test()");
+
+    const result = await runSyncCheck({ modulesRoot: "modules", appRoot: "examples" }, tmpDir);
+    expect(result.exitCode).toBe(0);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it("uses custom modulesRoot to rewrite glob patterns", async () => {
+    const srcDir = path.join(tmpDir, "custom-mods", "foo", "command");
+    const docDir = path.join(tmpDir, "custom-mods", "foo", "docs", "commands");
+    fs.mkdirSync(srcDir, { recursive: true });
+    fs.mkdirSync(docDir, { recursive: true });
+    fs.writeFileSync(path.join(srcDir, "createOrder.ts"), "export {}");
+    fs.writeFileSync(path.join(docDir, "createOrder.md"), "# CreateOrder");
+
+    const result = await runSyncCheck({ modulesRoot: "custom-mods" }, tmpDir);
+    expect(result.exitCode).toBe(0);
+    expect(result.summary.totalSources).toBe(1);
+  });
+
+  it("uses custom appRoot to rewrite glob patterns", async () => {
+    const srcDir = path.join(
+      tmpDir,
+      "apps",
+      "app1",
+      "backend",
+      "src",
+      "modules",
+      "m1",
+      "resolvers",
+    );
+    const docDir = path.join(tmpDir, "apps", "app1", "docs", "resolver");
+    fs.mkdirSync(srcDir, { recursive: true });
+    fs.mkdirSync(docDir, { recursive: true });
+    fs.writeFileSync(path.join(srcDir, "myResolver.ts"), "export {}");
+    fs.writeFileSync(path.join(docDir, "myResolver.md"), "# MyResolver");
+
+    const result = await runSyncCheck({ appRoot: "apps" }, tmpDir);
+    expect(result.exitCode).toBe(0);
+    expect(result.summary.totalSources).toBe(1);
+  });
+
+  it("checks only module patterns when appRoot is not set", async () => {
+    const resolverSrcDir = path.join(
+      tmpDir,
+      "examples",
+      "app1",
+      "backend",
+      "src",
+      "modules",
+      "m1",
+      "resolvers",
+    );
+    fs.mkdirSync(resolverSrcDir, { recursive: true });
+    fs.writeFileSync(path.join(resolverSrcDir, "myResolver.ts"), "export {}");
+
+    const result = await runSyncCheck({ modulesRoot: "modules", appRoot: undefined }, tmpDir);
+    // Without appRoot, app-compose patterns are not checked
+    expect(result.exitCode).toBe(0);
+    expect(result.errors).toHaveLength(0);
+  });
+});

package/src/commands/sync-check.ts

@@ -0,0 +1,182 @@
+import path from "node:path";
+import fg from "fast-glob";
+import chalk from "chalk";
+
+interface CategoryConfig {
+  name: string;
+  sourcePattern: string;
+  docPattern: string;
+  exclusions: RegExp[];
+}
+
+export interface CheckError {
+  type: "missing-doc" | "orphaned-doc";
+  category: string;
+  sourcePath?: string;
+  docPath?: string;
+  expectedBasename: string;
+}
+
+export interface SyncCheckResult {
+  exitCode: number;
+  errors: CheckError[];
+  summary: {
+    categoriesChecked: number;
+    totalSources: number;
+    totalDocs: number;
+  };
+}
+
+function moduleCategories(root: string): CategoryConfig[] {
+  return [
+    {
+      name: "command",
+      sourcePattern: `${root}/*/command/*.ts`,
+      docPattern: `${root}/*/docs/commands/*.md`,
+      exclusions: [/\.test\.ts$/],
+    },
+    {
+      name: "model",
+      sourcePattern: `${root}/*/db/*.ts`,
+      docPattern: `${root}/*/docs/models/*.md`,
+      exclusions: [/\.test\.ts$/, /^index\.ts$/],
+    },
+  ];
+}
+
+function appComposeCategories(root: string): CategoryConfig[] {
+  return [
+    {
+      name: "resolver",
+      sourcePattern: `${root}/*/backend/src/modules/**/resolvers/*.ts`,
+      docPattern: `${root}/*/docs/resolver/*.md`,
+      exclusions: [/\.test\.ts$/, /^index\.ts$/],
+    },
+  ];
+}
+
+function shouldExclude(fileName: string, exclusions: RegExp[]): boolean {
+  return exclusions.some((pattern) => pattern.test(fileName));
+}
+
+export async function runSyncCheck(
+  config: { modulesRoot?: string; appRoot?: string },
+  cwd: string,
+): Promise<SyncCheckResult> {
+  const errors: CheckError[] = [];
+  let totalSources = 0;
+  let totalDocs = 0;
+
+  const allCategories: CategoryConfig[] = [];
+  if (config.modulesRoot) {
+    allCategories.push(...moduleCategories(config.modulesRoot));
+  }
+  if (config.appRoot) {
+    allCategories.push(...appComposeCategories(config.appRoot));
+  }
+
+  for (const category of allCategories) {
+    const sources = await fg(category.sourcePattern, { cwd });
+    const docs = await fg(category.docPattern, { cwd });
+
+    const sourceBasenames = new Map<string, string>();
+    const docBasenames = new Map<string, string>();
+
+    for (const sourcePath of sources) {
+      const fileName = path.basename(sourcePath);
+      if (shouldExclude(fileName, category.exclusions)) continue;
+      const basename = path.basename(sourcePath, path.extname(sourcePath));
+      sourceBasenames.set(basename.toLowerCase(), sourcePath);
+    }
+
+    for (const docPath of docs) {
+      const basename = path.basename(docPath, path.extname(docPath));
+      docBasenames.set(basename.toLowerCase(), docPath);
+    }
+
+    for (const [basename, sourcePath] of sourceBasenames) {
+      if (!docBasenames.has(basename)) {
+        errors.push({
+          type: "missing-doc",
+          category: category.name,
+          sourcePath,
+          expectedBasename: basename,
+        });
+      }
+    }
+
+    for (const [basename, docPath] of docBasenames) {
+      if (!sourceBasenames.has(basename)) {
+        errors.push({
+          type: "orphaned-doc",
+          category: category.name,
+          docPath,
+          expectedBasename: basename,
+        });
+      }
+    }
+
+    totalSources += sourceBasenames.size;
+    totalDocs += docBasenames.size;
+  }
+
+  return {
+    exitCode: errors.length > 0 ? 1 : 0,
+    errors,
+    summary: {
+      categoriesChecked: allCategories.length,
+      totalSources,
+      totalDocs,
+    },
+  };
+}
+
+export function formatSyncCheckReport(result: SyncCheckResult): string {
+  const lines: string[] = [];
+  lines.push(chalk.bold("docs-sync-check: Checking source-documentation correspondence...\n"));
+
+  if (result.errors.length > 0) {
+    lines.push(chalk.red.bold("Errors:\n"));
+    const byCategory = new Map<string, CheckError[]>();
+    for (const error of result.errors) {
+      const existing = byCategory.get(error.category) ?? [];
+      existing.push(error);
+      byCategory.set(error.category, existing);
+    }
+    for (const [category, categoryErrors] of byCategory) {
+      lines.push(chalk.cyan(`  Category: ${category}\n`));
+      for (const error of categoryErrors) {
+        if (error.type === "missing-doc") {
+          lines.push(`  ${chalk.red(error.sourcePath)}`);
+          lines.push(`    ${chalk.yellow("Missing documentation for:")} ${error.expectedBasename}`);
+        } else {
+          lines.push(`  ${chalk.red(error.docPath)}`);
+          lines.push(
+            `    ${chalk.yellow("Orphaned documentation:")} no source file for ${error.expectedBasename}`,
+          );
+        }
+        lines.push("");
+      }
+    }
+  } else {
+    lines.push(chalk.green("All source files have corresponding documentation.\n"));
+  }
+
+  lines.push(chalk.bold("Summary:"));
+  lines.push(`  Categories checked: ${result.summary.categoriesChecked}`);
+  lines.push(
+    `  Source files: ${result.summary.totalSources}, Doc files: ${result.summary.totalDocs}`,
+  );
+
+  if (result.errors.length > 0) {
+    lines.push(chalk.red(`  Errors: ${result.errors.length}`));
+    lines.push("");
+    lines.push(chalk.red.bold(`docs-sync-check failed with ${result.errors.length} error(s).`));
+  } else {
+    lines.push(chalk.green("  Errors: 0"));
+    lines.push("");
+    lines.push(chalk.green.bold("docs-sync-check passed."));
+  }
+
+  return lines.join("\n");
+}

package/src/integration.test.ts

@@ -0,0 +1,63 @@
+import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import fs from "node:fs";
+import path from "node:path";
+import { describe, it, expect } from "vitest";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const CLI_PATH = path.resolve(__dirname, "..", "dist", "cli.js");
+const REPO_ROOT = path.resolve(__dirname, "..", "..", "..");
+
+const skipReason = fs.existsSync(CLI_PATH) ? undefined : "Run `pnpm build` first";
+
+describe.skipIf(skipReason)("integration", () => {
+  it("check command runs against sdk-plugins modules", () => {
+    // mdschema may report validation errors in real docs, so we allow non-zero exit codes
+    // but verify the CLI itself doesn't crash with an unexpected error
+    try {
+      const result = execFileSync(
+        "node",
+        [CLI_PATH, "check", "--modules-root", "packages/erp-kit/src/modules"],
+        {
+          cwd: REPO_ROOT,
+          encoding: "utf-8",
+          env: { ...process.env },
+        },
+      );
+      expect(result).toBeDefined();
+    } catch (err: unknown) {
+      const error = err as { status: number; stderr: string };
+      // exit code 1 = validation errors in docs (acceptable)
+      // exit code 2 = CLI usage error (unexpected)
+      expect(error.status).toBe(1);
+    }
+  });
+
+  it("sync-check command runs against sdk-plugins modules", () => {
+    try {
+      const result = execFileSync(
+        "node",
+        [CLI_PATH, "sync-check", "--modules-root", "packages/erp-kit/src/modules"],
+        {
+          cwd: REPO_ROOT,
+          encoding: "utf-8",
+          env: { ...process.env },
+        },
+      );
+      expect(result).toContain("docs-sync-check");
+    } catch (err: unknown) {
+      const error = err as { status: number; stdout: string };
+      // sync-check may fail with errors=1 but should still produce a report
+      expect(error.stdout).toContain("docs-sync-check");
+    }
+  });
+
+  it("--help prints usage", () => {
+    const result = execFileSync("node", [CLI_PATH, "--help"], {
+      encoding: "utf-8",
+    });
+    expect(result).toContain("erp-kit");
+    expect(result).toContain("check");
+    expect(result).toContain("scaffold");
+  });
+});

package/src/mdschema.ts

@@ -0,0 +1,48 @@
+import path from "node:path";
+import fs from "node:fs";
+import { execFile } from "node:child_process";
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+
+interface PackageJson {
+  bin?: string | Record<string, string>;
+}
+
+export function getMdschemaBin(): string {
+  const pkgPath = require.resolve("@jackchuka/mdschema/package.json");
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8")) as PackageJson;
+  const bin = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.mdschema;
+  if (!bin) {
+    throw new Error("Could not resolve mdschema binary from package.json bin field");
+  }
+  return path.join(path.dirname(pkgPath), bin);
+}
+
+export interface MdschemaResult {
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+}
+
+export function runMdschema(args: string[], cwd?: string): Promise<MdschemaResult> {
+  return new Promise((resolve) => {
+    execFile(
+      getMdschemaBin(),
+      args,
+      { encoding: "utf-8", cwd, timeout: 30_000 },
+      (error, stdout, stderr) => {
+        if (error) {
+          const execError = error as NodeJS.ErrnoException & { status?: number };
+          resolve({
+            exitCode: execError.code === "ENOENT" ? 127 : (execError.status ?? 1),
+            stdout: stdout ?? "",
+            stderr: stderr ?? "",
+          });
+        } else {
+          resolve({ exitCode: 0, stdout: stdout ?? "", stderr: stderr ?? "" });
+        }
+      },
+    );
+  });
+}

package/src/mockServer.ts

@@ -0,0 +1,55 @@
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+
+export interface MockServer {
+  url: string;
+  port: number;
+  stop: () => Promise<void>;
+}
+
+/**
+ * Start a Mockoon mock server from a mock.json file.
+ * Returns a handle with the server URL and a stop function.
+ */
+export async function createMockServer(mockJsonPath: string, port?: number): Promise<MockServer> {
+  const { MockoonServer, createLoggerInstance, listenServerEvents } =
+    await import("@mockoon/commons-server");
+  type Environment = import("@mockoon/commons").Environment;
+
+  const resolvedPath = resolve(mockJsonPath);
+  const environment = JSON.parse(readFileSync(resolvedPath, "utf-8")) as Environment;
+  if (port !== undefined) {
+    environment.port = port;
+  }
+  const actualPort = environment.port;
+
+  const logger = createLoggerInstance(null);
+  const server = new MockoonServer(environment, {
+    environmentDirectory: dirname(resolvedPath),
+    enableAdminApi: false,
+    disableTls: true,
+    enableRandomLatency: false,
+    maxTransactionLogs: 100,
+    envVarsPrefix: "MOCKOON_",
+  });
+
+  listenServerEvents(server, environment, logger, false);
+
+  await new Promise<void>((resolve, reject) => {
+    server.on("started", resolve);
+    server.on("error", (errorCode, originalError) => {
+      reject(originalError ?? new Error(`Mockoon error: ${errorCode}`));
+    });
+    server.start();
+  });
+
+  return {
+    url: `http://127.0.0.1:${actualPort}`,
+    port: actualPort,
+    stop: () =>
+      new Promise<void>((resolve) => {
+        server.on("stopped", resolve);
+        server.stop();
+      }),
+  };
+}

package/src/module.ts

@@ -0,0 +1,86 @@
+// shared/internal
+export { defineCommand, type Command } from "./modules/shared/defineCommand";
+export { definePermissions } from "./modules/shared/definePermissions";
+export { requirePermission } from "./modules/shared/requirePermission";
+export { createDomainError, InsufficientPermissionError } from "./modules/shared/errors";
+export type { CommandContext } from "./modules/shared/types";
+export type {
+  InferSchema,
+  Selectable,
+  Insertable,
+  Updateable,
+  FieldsToInsertable,
+} from "./modules/shared/entityTypes";
+
+// primitives
+export { defineModule as definePrimitivesModule } from "./modules/primitives/module";
+export {
+  permissions as primitivesPermissions,
+  own as primitivesOwn,
+  all as primitivesAll,
+} from "./modules/primitives/permissions";
+export {
+  UoMCategoryNotFoundError,
+  UnitNotFoundError,
+  IncompatibleUnitsError,
+  InactiveUnitError,
+  CurrencyNotFoundError,
+  InactiveCurrencyError,
+  ExchangeRateNotFoundError,
+  CannotDeactivateReferenceUnitError,
+  CategoryNotActiveError,
+  DuplicateUnitSymbolError,
+  InvalidConversionFactorError,
+  InvalidRoundingPrecisionError,
+  DuplicateCategoryNameError,
+  CategoryHasActiveUnitsError,
+  UnitNotInCategoryError,
+  InvalidISOCodeError,
+  DuplicateCurrencyCodeError,
+  InvalidDecimalPlacesError,
+  CannotDeactivateBaseCurrencyError,
+  CannotSetInactiveAsBaseCurrencyError,
+  SameCurrencyPairError,
+  InvalidExchangeRateError,
+} from "./modules/primitives/lib/errors";
+export { type ConvertQuantityInput } from "./modules/primitives/command/convertQuantity";
+export { type ActivateCategoryInput } from "./modules/primitives/command/activateCategory";
+export { type DeactivateCategoryInput } from "./modules/primitives/command/deactivateCategory";
+export { type SetReferenceUnitInput } from "./modules/primitives/command/setReferenceUnit";
+export { type ActivateUnitInput } from "./modules/primitives/command/activateUnit";
+export { type DeactivateUnitInput } from "./modules/primitives/command/deactivateUnit";
+export { type ConvertAmountInput } from "./modules/primitives/command/convertAmount";
+export { type ActivateCurrencyInput } from "./modules/primitives/command/activateCurrency";
+export { type DeactivateCurrencyInput } from "./modules/primitives/command/deactivateCurrency";
+export { type SetBaseCurrencyInput } from "./modules/primitives/command/setBaseCurrency";
+// user-management
+export { defineModule as defineUserManagementModule } from "./modules/user-management/module";
+export {
+  permissions as userManagementPermissions,
+  own as userManagementOwn,
+  all as userManagementAll,
+} from "./modules/user-management/permissions";
+export { AuditEventEventType, UserStatus } from "./modules/user-management/generated/enums";
+export {
+  UserNotFoundError,
+  UserAlreadyExistsError,
+  UserNotActiveError,
+  InvalidEmailError,
+  MissingRequiredFieldError,
+  InvalidStatusTransitionError,
+  PermissionNotFoundError,
+  DuplicatePermissionKeyError,
+  InvalidPermissionKeyFormatError,
+  RoleNotFoundError,
+  DuplicateRoleNameError,
+  AssignmentNotFoundError,
+  InvalidEventTypeError,
+} from "./modules/user-management/lib/errors";
+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";
+export { type AssignPermissionToRoleInput } from "./modules/user-management/command/assignPermissionToRole";
+export { type RevokePermissionFromRoleInput } from "./modules/user-management/command/revokePermissionFromRole";
+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";