@tailor-platform/erp-kit 0.2.0 → 0.2.2

package/src/modules/user-management/command/revokeRoleFromUser.test.ts

@@ -1,34 +1,23 @@
 import { describe, expect, it } from "vitest";
-import { type CommandContext } from "../../shared/internal";
-import { createMockDb } from "../../testing/index";
-import { DB } from "../generated/kysely-tailordb";
+import { createMockDb } from "../../../testing/index";
+import { Transaction } from "../generated/kysely-tailordb";
 import {
   AssignmentNotFoundError,
   RoleNotFoundError,
   UserNotFoundError,
 } from "../lib/errors.generated";
-import { activeUser, baseAuditEvent, baseRole, baseUserRole } from "../testing/fixtures";
+import { activeUser, baseRole, baseUserRole } from "../testing/fixtures";
 import { run } from "./revokeRoleFromUser";
 
 describe("revokeRoleFromUser", () => {
-  const ctx: CommandContext = {
-    actorId: "test-actor",
-    permissions: ["user-management:revokeRoleFromUser"],
-  };
-
   it("throws when user does not exist", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValue(undefined);
 
-    const result = await run(
-      db,
-      {
-        userId: "nonexistent-user",
-        roleId: baseRole.id,
-        actorId: "actor-1",
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      userId: "nonexistent-user",
+      roleId: baseRole.id,
+    });
     expect(result.ok).toBe(false);
     if (!result.ok) {
       expect(result.error).toBeInstanceOf(UserNotFoundError);
@@ -36,18 +25,13 @@ describe("revokeRoleFromUser", () => {
   });
 
   it("throws when role does not exist", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce(activeUser).mockReturnValueOnce(undefined);
 
-    const result = await run(
-      db,
-      {
-        userId: activeUser.id,
-        roleId: "nonexistent-role",
-        actorId: "actor-1",
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      userId: activeUser.id,
+      roleId: "nonexistent-role",
+    });
     expect(result.ok).toBe(false);
     if (!result.ok) {
       expect(result.error).toBeInstanceOf(RoleNotFoundError);
@@ -55,36 +39,24 @@ describe("revokeRoleFromUser", () => {
   });
 
   it("throws when assignment does not exist", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select
       .mockReturnValueOnce(activeUser)
       .mockReturnValueOnce(baseRole)
       .mockReturnValueOnce(undefined);
 
-    const result = await run(
-      db,
-      {
-        userId: activeUser.id,
-        roleId: baseRole.id,
-        actorId: "actor-1",
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      userId: activeUser.id,
+      roleId: baseRole.id,
+    });
     expect(result.ok).toBe(false);
     if (!result.ok) {
       expect(result.error).toBeInstanceOf(AssignmentNotFoundError);
     }
   });
 
-  it("deletes UserRole and logs ROLE_REVOKED event", async () => {
-    const { db, spies } = createMockDb<DB>();
-    const createdAuditEvent = {
-      ...baseAuditEvent,
-      eventType: "ROLE_REVOKED" as const,
-      actorId: "actor-1",
-      targetId: activeUser.id,
-      targetType: "User",
-    };
+  it("deletes UserRole and recomputes permissions", async () => {
+    const { db, spies } = createMockDb<Transaction>();
     const updatedUser = { ...activeUser, permissions: [] };
 
     spies.select
@@ -93,23 +65,15 @@ describe("revokeRoleFromUser", () => {
       .mockReturnValueOnce(baseUserRole)
       .mockReturnValueOnce([]); // Permission keys from recompute (empty after revoke)
     spies.delete.mockReturnValue(baseUserRole);
-    spies.insert.mockReturnValue(createdAuditEvent);
     spies.update.mockReturnValue(updatedUser);
 
-    const result = await run(
-      db,
-      {
-        userId: activeUser.id,
-        roleId: baseRole.id,
-        actorId: "actor-1",
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      userId: activeUser.id,
+      roleId: baseRole.id,
+    });
 
     expect(result.ok).toBe(true);
     if (result.ok) {
-      expect(result.value.auditEvent.eventType).toBe("ROLE_REVOKED");
-      expect(result.value.auditEvent.targetId).toBe(activeUser.id);
       expect(result.value.user.permissions).toEqual([]);
     }
     expect(spies.delete).toHaveBeenCalled();

package/src/modules/user-management/command/revokeRoleFromUser.ts

@@ -1,5 +1,5 @@
-import { ok, err, type CommandContext } from "../../shared/internal";
-import { DB } from "../generated/kysely-tailordb";
+import { ok, err } from "../../../shared";
+import { Transaction } from "../generated/kysely-tailordb";
 import {
   AssignmentNotFoundError,
   RoleNotFoundError,
@@ -10,7 +10,6 @@ import { recomputeUserPermissions } from "../lib/recomputeUserPermissions";
 export interface RevokeRoleFromUserInput {
   userId: string;
   roleId: string;
-  actorId: string;
 }
 
 /**
@@ -19,8 +18,7 @@ export interface RevokeRoleFromUserInput {
  * Removes a role from a user.
  * Throws an error if the assignment does not exist.
  */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export async function run(db: DB, input: RevokeRoleFromUserInput, _ctx: CommandContext) {
+export async function run(db: Transaction, input: RevokeRoleFromUserInput) {
   const user = await db
     .selectFrom("User")
     .selectAll()
@@ -46,6 +44,7 @@ export async function run(db: DB, input: RevokeRoleFromUserInput, _ctx: CommandC
     .selectAll()
     .where("userId", "=", input.userId)
     .where("roleId", "=", input.roleId)
+    .forUpdate()
     .executeTakeFirst();
 
   if (!existingAssignment) {
@@ -58,25 +57,7 @@ export async function run(db: DB, input: RevokeRoleFromUserInput, _ctx: CommandC
     .returningAll()
     .executeTakeFirst();
 
-  const auditEvent = await db
-    .insertInto("AuditEvent")
-    .values({
-      eventType: "ROLE_REVOKED",
-      actorId: input.actorId,
-      targetId: input.userId,
-      targetType: "User",
-      payload: JSON.stringify({
-        userId: input.userId,
-        roleId: input.roleId,
-        roleName: role.name,
-      }),
-      createdAt: new Date(),
-      updatedAt: null,
-    })
-    .returningAll()
-    .executeTakeFirst();
-
   const updatedUser = await recomputeUserPermissions(db, input.userId);
 
-  return ok({ user: updatedUser, auditEvent: auditEvent! });
+  return ok({ user: updatedUser });
 }

package/src/modules/user-management/docs/commands/ActivateUser.md

@@ -34,3 +34,10 @@ flowchart TD
 
 - **USER_NOT_FOUND**: User ID does not exist in the system - return not found error with the provided ID
 - **INVALID_STATUS_TRANSITION**: User is not in PENDING status (already ACTIVE or INACTIVE) - return error with current status and valid transitions
+
+## Test Cases
+
+- throws when user does not exist
+- throws when user is already ACTIVE
+- throws when user is INACTIVE (use reactivateUser instead)
+- activates PENDING user to ACTIVE

package/src/modules/user-management/docs/commands/AssignPermissionToRole.md

@@ -37,3 +37,10 @@ flowchart TD
 
 - **ROLE_NOT_FOUND**: Role ID does not exist in the system - return not found error with the provided role ID
 - **PERMISSION_NOT_FOUND**: Permission ID does not exist in the system - return not found error with the provided permission ID
+
+## Test Cases
+
+- throws when role does not exist
+- throws when permission does not exist
+- returns success when assignment already exists (idempotent)
+- creates RolePermission

package/src/modules/user-management/docs/commands/AssignRoleToUser.md

@@ -41,3 +41,12 @@ flowchart TD
 - **USER_NOT_FOUND**: User ID does not exist in the system - return not found error with the provided user ID
 - **ROLE_NOT_FOUND**: Role ID does not exist in the system - return not found error with the provided role ID
 - **USER_NOT_ACTIVE**: User is in PENDING or INACTIVE status - return error indicating only ACTIVE users can receive role assignments
+
+## Test Cases
+
+- throws when user does not exist
+- throws when role does not exist
+- throws when user is PENDING
+- throws when user is INACTIVE
+- returns success when assignment already exists (idempotent)
+- creates UserRole and recomputes permissions

package/src/modules/user-management/docs/commands/CreatePermission.md

@@ -33,3 +33,15 @@ flowchart TD
 
 - **INVALID_PERMISSION_KEY_FORMAT**: Key does not match `resource:action` pattern
 - **DUPLICATE_PERMISSION_KEY**: Permission with the same key already exists
+
+## Test Cases
+
+- throws when key is empty
+- throws when key format is invalid (no colon)
+- throws when key format is invalid (multiple colons)
+- throws when key format is invalid (empty resource)
+- throws when key format is invalid (empty action)
+- throws when permission key already exists
+- creates permission with valid key
+- creates permission with description
+- passes custom fields through to insert

package/src/modules/user-management/docs/commands/CreateRole.md

@@ -33,3 +33,12 @@ flowchart TD
 
 - **MISSING_REQUIRED_FIELD**: Role name not provided - return validation error indicating name is required
 - **DUPLICATE_ROLE_NAME**: Role with the same name already exists
+
+## Test Cases
+
+- throws when name is empty
+- throws when name is whitespace only
+- throws when role name already exists
+- creates role with valid name
+- creates role with description
+- passes custom fields through to insert

package/src/modules/user-management/docs/commands/CreateUser.md

@@ -39,3 +39,14 @@ flowchart TD
 - **USER_ALREADY_EXISTS**: Email address is already registered in the system - return conflict error with message indicating email is taken
 - **INVALID_EMAIL**: Email does not follow valid email format - return validation error with format requirements
 - **MISSING_REQUIRED_FIELD**: Name or email not provided - return validation error listing missing fields
+
+## Test Cases
+
+- throws when email is empty
+- throws when name is empty
+- throws when name is whitespace only
+- throws when email format is invalid (no @)
+- throws when email format is invalid (no domain)
+- throws when email already exists
+- creates user with PENDING status
+- passes custom fields through to insert

package/src/modules/user-management/docs/commands/DeactivateUser.md

@@ -36,3 +36,10 @@ flowchart TD
 
 - **USER_NOT_FOUND**: User ID does not exist in the system - return not found error with the provided ID
 - **INVALID_STATUS_TRANSITION**: User is not in ACTIVE status (PENDING or already INACTIVE) - return error with current status and valid transitions
+
+## Test Cases
+
+- throws when user does not exist
+- throws when user is PENDING
+- throws when user is already INACTIVE
+- deactivates ACTIVE user to INACTIVE

package/src/modules/user-management/docs/commands/ReactivateUser.md

@@ -35,3 +35,10 @@ flowchart TD
 
 - **USER_NOT_FOUND**: User ID does not exist in the system - return not found error with the provided ID
 - **INVALID_STATUS_TRANSITION**: User is not in INACTIVE status (PENDING or already ACTIVE) - return error with current status and valid transitions
+
+## Test Cases
+
+- throws when user does not exist
+- throws when user is PENDING
+- throws when user is already ACTIVE
+- reactivates INACTIVE user to ACTIVE

package/src/modules/user-management/docs/commands/RevokePermissionFromRole.md

@@ -38,3 +38,10 @@ flowchart TD
 - **ROLE_NOT_FOUND**: Role ID does not exist in the system - return not found error with the provided role ID
 - **PERMISSION_NOT_FOUND**: Permission ID does not exist in the system - return not found error with the provided permission ID
 - **ASSIGNMENT_NOT_FOUND**: Role does not have this permission assigned - return not found error indicating the association does not exist
+
+## Test Cases
+
+- throws when role does not exist
+- throws when permission does not exist
+- throws when assignment does not exist
+- deletes RolePermission

package/src/modules/user-management/docs/commands/RevokeRoleFromUser.md

@@ -38,3 +38,10 @@ flowchart TD
 - **USER_NOT_FOUND**: User ID does not exist in the system - return not found error with the provided user ID
 - **ROLE_NOT_FOUND**: Role ID does not exist in the system - return not found error with the provided role ID
 - **ASSIGNMENT_NOT_FOUND**: User does not have this role assigned - return not found error indicating the association does not exist
+
+## Test Cases
+
+- throws when user does not exist
+- throws when role does not exist
+- throws when assignment does not exist
+- deletes UserRole and recomputes permissions

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

@@ -1,32 +1,2 @@
 export { defineModule } from "./module";
 export { permissions, own, all } from "./lib/permissions.generated";
-
-// generated types
-export { AuditEventEventType, UserStatus } from "./generated/enums";
-
-// errors
-export {
-  UserNotFoundError,
-  UserAlreadyExistsError,
-  UserNotActiveError,
-  InvalidEmailError,
-  MissingRequiredFieldError,
-  InvalidStatusTransitionError,
-  PermissionNotFoundError,
-  DuplicatePermissionKeyError,
-  InvalidPermissionKeyFormatError,
-  RoleNotFoundError,
-  DuplicateRoleNameError,
-  AssignmentNotFoundError,
-  InvalidEventTypeError,
-} from "./lib/errors.generated";
-
-// input types
-export { type ActivateUserInput } from "./command/activateUser";
-export { type DeactivateUserInput } from "./command/deactivateUser";
-export { type ReactivateUserInput } from "./command/reactivateUser";
-export { type AssignPermissionToRoleInput } from "./command/assignPermissionToRole";
-export { type RevokePermissionFromRoleInput } from "./command/revokePermissionFromRole";
-export { type AssignRoleToUserInput } from "./command/assignRoleToUser";
-export { type RevokeRoleFromUserInput } from "./command/revokeRoleFromUser";
-export { type LogAuditEventInput } from "./command/logAuditEvent";

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

@@ -1,67 +1,67 @@
 // @generated — do not edit
-import { createDomainError } from "../../shared/internal";
+import { createDomainError } from "../../../shared";
 
 export const UserNotFoundError = createDomainError(
-  "UserNotFoundError", "USER_NOT_FOUND",
+  "UserNotFoundError", "USER_MANAGEMENT_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",
+  "InvalidStatusTransitionError", "USER_MANAGEMENT_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",
+  "RoleNotFoundError", "USER_MANAGEMENT_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",
+  "PermissionNotFoundError", "USER_MANAGEMENT_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",
+  "UserNotActiveError", "USER_MANAGEMENT_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",
+  "InvalidPermissionKeyFormatError", "USER_MANAGEMENT_INVALID_PERMISSION_KEY_FORMAT",
   (identifier: string) => `Key does not match resource:action pattern: ${identifier}`,
 );
 
 export const DuplicatePermissionKeyError = createDomainError(
-  "DuplicatePermissionKeyError", "DUPLICATE_PERMISSION_KEY",
+  "DuplicatePermissionKeyError", "USER_MANAGEMENT_DUPLICATE_PERMISSION_KEY",
   (identifier: string) => `Permission with the same key already exists: ${identifier}`,
 );
 
 export const MissingRequiredFieldError = createDomainError(
-  "MissingRequiredFieldError", "MISSING_REQUIRED_FIELD",
+  "MissingRequiredFieldError", "USER_MANAGEMENT_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",
+  "DuplicateRoleNameError", "USER_MANAGEMENT_DUPLICATE_ROLE_NAME",
   (identifier: string) => `Role with the same name already exists: ${identifier}`,
 );
 
 export const UserAlreadyExistsError = createDomainError(
-  "UserAlreadyExistsError", "USER_ALREADY_EXISTS",
+  "UserAlreadyExistsError", "USER_MANAGEMENT_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",
+  "InvalidEmailError", "USER_MANAGEMENT_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",
+  "InvalidEventTypeError", "USER_MANAGEMENT_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",
+  "AssignmentNotFoundError", "USER_MANAGEMENT_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/lib/permissions.generated.ts

@@ -1,5 +1,5 @@
 // @generated — do not edit
-import { definePermissions } from "../../shared/internal";
+import { definePermissions } from "../../../shared";
 
 export const { permissions, own, all } = definePermissions("user-management", [
   "activateUser",
@@ -9,7 +9,6 @@ export const { permissions, own, all } = definePermissions("user-management", [
   "createRole",
   "createUser",
   "deactivateUser",
-  "logAuditEvent",
   "reactivateUser",
   "revokePermissionFromRole",
   "revokeRoleFromUser",

package/src/modules/user-management/lib/recomputeUserPermissions.ts

@@ -1,11 +1,12 @@
-import { Kysely } from "kysely";
+import { type TailordbKysely } from "@tailor-platform/sdk/kysely";
+import type { Transaction as KyselyTransaction } from "kysely";
 import { DB } from "../generated/kysely-tailordb";
 import { User } from "./types";
 
 export const recomputeUserPermissions = async <
   T extends { User: object; UserRole: object; RolePermission: object; Permission: object },
 >(
-  db: Kysely<T>,
+  db: TailordbKysely<T> | KyselyTransaction<T>,
   userId: string,
 ): Promise<User<T>> => {
   const _db = db as unknown as DB;
@@ -33,7 +34,7 @@ export const recomputeUserPermissions = async <
 export const recomputePermissionsForUsersWithRole = async <
   T extends { User: object; UserRole: object; RolePermission: object; Permission: object },
 >(
-  db: Kysely<T>,
+  db: TailordbKysely<T> | KyselyTransaction<T>,
   roleId: string,
 ): Promise<User<T>[]> => {
   const _db = db as unknown as DB;

package/src/modules/user-management/lib/types.ts

@@ -1,4 +1,4 @@
-import type { InferSchema, Selectable, Insertable, Updateable } from "../../shared/internal";
+import type { InferSchema, Selectable, Insertable, Updateable } from "../../../shared";
 import type { DB } from "../generated/kysely-tailordb";
 
 export type Schema = InferSchema<DB>;

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

@@ -1,5 +1,5 @@
 import { type TailorAnyDBField } from "@tailor-platform/sdk";
-import { type EmptyFields, type FieldsToInsertable } from "../shared/internal";
+import { type EmptyFields, type FieldsToInsertable } from "../../shared";
 import { createUser } from "./command/createUser.generated";
 import { createRole } from "./command/createRole.generated";
 import { createPermission } from "./command/createPermission.generated";
@@ -10,8 +10,6 @@ import { assignPermissionToRole } from "./command/assignPermissionToRole.generat
 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";
 import { createRolePermissionType, CreateRolePermissionTypeParams } from "./db/rolePermission";
@@ -33,7 +31,6 @@ export interface DefineModuleParams<
   role?: CreateRoleTypeParams<RF>;
   userRole?: CreateUserRoleTypeParams;
   rolePermission?: CreateRolePermissionTypeParams;
-  auditEvent?: CreateAuditEventTypeParams;
 }
 
 export const defineModule = <
@@ -48,7 +45,6 @@ export const defineModule = <
   const role = createRoleType(params.role ?? {});
   const userRole = createUserRoleType(params.userRole ?? {});
   const rolePermission = createRolePermissionType(params.rolePermission ?? {});
-  const auditEvent = createAuditEventType(params.auditEvent ?? {});
 
   const rolePermissionCreated = recomputeOnRolePermissionCreated({
     namespace: params.dbNamespace,
@@ -58,7 +54,7 @@ export const defineModule = <
   });
 
   return {
-    db: { user, permission, role, userRole, rolePermission, auditEvent },
+    db: { user, permission, role, userRole, rolePermission },
     executors: { rolePermissionCreated, rolePermissionDeleted },
     commands: {
       createUser: createUser<FieldsToInsertable<UF>>(),
@@ -71,7 +67,6 @@ export const defineModule = <
       revokePermissionFromRole: revokePermissionFromRole(),
       assignRoleToUser: assignRoleToUser(),
       revokeRoleFromUser: revokeRoleFromUser(),
-      logAuditEvent: logAuditEvent(),
     },
   };
 };

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

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

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

@@ -0,0 +1,13 @@
+// This file is auto-generated by @tailor-platform/sdk
+// Do not edit this file manually
+// Regenerated automatically when running 'tailor-sdk apply' or 'tailor-sdk generate'
+
+declare module "@tailor-platform/sdk" {
+  interface AttributeMap {}
+  interface AttributeList {
+    __tuple?: [];
+  }
+  interface Env {}
+}
+
+export {};

package/src/modules/user-management/testing/fixtures.ts

@@ -1,12 +1,4 @@
-import type {
-  AuditEvent,
-  Permission,
-  Role,
-  RolePermission,
-  Schema,
-  User,
-  UserRole,
-} from "../lib/types";
+import type { Permission, Role, RolePermission, Schema, User, UserRole } from "../lib/types";
 
 export const pendingUser = {
   id: "user-pending-1",
@@ -85,14 +77,3 @@ export const baseRolePermission = {
   createdAt: new Date("2024-01-01T00:00:00.000Z"),
   updatedAt: null,
 } as const satisfies RolePermission<Schema>;
-
-export const baseAuditEvent = {
-  id: "audit-event-1",
-  eventType: "USER_CREATED",
-  actorId: "user-active-1",
-  targetId: "user-pending-1",
-  targetType: "User",
-  payload: JSON.stringify({ email: "pending@example.com" }),
-  createdAt: new Date("2024-01-01T00:00:00.000Z"),
-  updatedAt: null,
-} as const satisfies AuditEvent<Schema>;

package/src/schemas.ts

@@ -12,7 +12,7 @@ export const MODULE_SCHEMAS = {
 } as const;
 
 export const APP_COMPOSE_SCHEMAS = {
-  requirements: path.join(SCHEMAS_ROOT, "app-compose", "requirements.yml"),
+  app: path.join(SCHEMAS_ROOT, "app-compose", "requirements.yml"),
   actors: path.join(SCHEMAS_ROOT, "app-compose", "actors.yml"),
   "business-flow": path.join(SCHEMAS_ROOT, "app-compose", "business-flow.yml"),
   story: path.join(SCHEMAS_ROOT, "app-compose", "story.yml"),