@tailor-platform/erp-kit 0.0.1 → 0.1.1

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

@@ -0,0 +1,81 @@
+import { createDomainError } from "../../shared/internal";
+
+export const UserNotFoundError = createDomainError(
+  "UserNotFoundError",
+  "USER_NOT_FOUND",
+  (userId: string) => `User not found: ${userId}`,
+);
+
+export const UserAlreadyExistsError = createDomainError(
+  "UserAlreadyExistsError",
+  "USER_ALREADY_EXISTS",
+  (email: string) => `User with email "${email}" already exists`,
+);
+
+export const UserNotActiveError = createDomainError(
+  "UserNotActiveError",
+  "USER_NOT_ACTIVE",
+  (userId: string, status: string) => `User ${userId} is not active (current status: ${status})`,
+);
+
+export const InvalidEmailError = createDomainError(
+  "InvalidEmailError",
+  "INVALID_EMAIL",
+  (email: string) => `Invalid email format: ${email}`,
+);
+
+export const MissingRequiredFieldError = createDomainError(
+  "MissingRequiredFieldError",
+  "MISSING_REQUIRED_FIELD",
+  (field: string) => `Missing required field: ${field}`,
+);
+
+export const InvalidStatusTransitionError = createDomainError(
+  "InvalidStatusTransitionError",
+  "INVALID_STATUS_TRANSITION",
+  (currentStatus: string, targetStatus: string) =>
+    `Invalid status transition from ${currentStatus} to ${targetStatus}`,
+);
+
+export const PermissionNotFoundError = createDomainError(
+  "PermissionNotFoundError",
+  "PERMISSION_NOT_FOUND",
+  (permissionId: string) => `Permission not found: ${permissionId}`,
+);
+
+export const DuplicatePermissionKeyError = createDomainError(
+  "DuplicatePermissionKeyError",
+  "DUPLICATE_PERMISSION_KEY",
+  (key: string) => `Permission with key "${key}" already exists`,
+);
+
+export const InvalidPermissionKeyFormatError = createDomainError(
+  "InvalidPermissionKeyFormatError",
+  "INVALID_PERMISSION_KEY_FORMAT",
+  (key: string) => `Invalid permission key format: "${key}". Expected format: resource:action`,
+);
+
+export const RoleNotFoundError = createDomainError(
+  "RoleNotFoundError",
+  "ROLE_NOT_FOUND",
+  (roleId: string) => `Role not found: ${roleId}`,
+);
+
+export const DuplicateRoleNameError = createDomainError(
+  "DuplicateRoleNameError",
+  "DUPLICATE_ROLE_NAME",
+  (name: string) => `Role with name "${name}" already exists`,
+);
+
+export const AssignmentNotFoundError = createDomainError(
+  "AssignmentNotFoundError",
+  "ASSIGNMENT_NOT_FOUND",
+  (sourceType: string, sourceId: string, targetType: string, targetId: string) =>
+    `Assignment not found: ${sourceType} ${sourceId} -> ${targetType} ${targetId}`,
+);
+
+export const InvalidEventTypeError = createDomainError(
+  "InvalidEventTypeError",
+  "INVALID_EVENT_TYPE",
+  (eventType: string) => `Invalid event type: ${eventType}`,
+);

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

@@ -0,0 +1,53 @@
+import { Kysely } 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>,
+  userId: string,
+): Promise<User<T>> => {
+  const _db = db as unknown as DB;
+
+  const permissionRows = await _db
+    .selectFrom("UserRole")
+    .innerJoin("RolePermission", "RolePermission.roleId", "UserRole.roleId")
+    .innerJoin("Permission", "Permission.id", "RolePermission.permissionId")
+    .select("Permission.key")
+    .where("UserRole.userId", "=", userId)
+    .execute();
+
+  const permissions = [...new Set(permissionRows.map((row) => row.key))].sort();
+
+  const updatedUser = await _db
+    .updateTable("User")
+    .set({ permissions, updatedAt: new Date() })
+    .where("id", "=", userId)
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  return updatedUser as unknown as User<T>;
+};
+
+export const recomputePermissionsForUsersWithRole = async <
+  T extends { User: object; UserRole: object; RolePermission: object; Permission: object },
+>(
+  db: Kysely<T>,
+  roleId: string,
+): Promise<User<T>[]> => {
+  const _db = db as unknown as DB;
+
+  const userRoles = await _db
+    .selectFrom("UserRole")
+    .select("userId")
+    .where("roleId", "=", roleId)
+    .execute();
+
+  const updatedUsers: User<T>[] = [];
+  for (const { userId } of userRoles) {
+    const user = await recomputeUserPermissions(db, userId);
+    updatedUsers.push(user);
+  }
+  return updatedUsers;
+};

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

@@ -0,0 +1,31 @@
+import type { InferSchema, Selectable, Insertable, Updateable } from "../../shared/internal";
+import type { DB } from "../generated/kysely-tailordb";
+
+export type Schema = InferSchema<DB>;
+
+export type User<T extends { User: object }> = Selectable<T["User"]>;
+export type UserCreate<T extends { User: object }> = Insertable<T["User"]>;
+export type UserUpdate<T extends { User: object }> = Updateable<T["User"]>;
+
+export type Permission<T extends { Permission: object }> = Selectable<T["Permission"]>;
+export type PermissionCreate<T extends { Permission: object }> = Insertable<T["Permission"]>;
+export type PermissionUpdate<T extends { Permission: object }> = Updateable<T["Permission"]>;
+
+export type Role<T extends { Role: object }> = Selectable<T["Role"]>;
+export type RoleCreate<T extends { Role: object }> = Insertable<T["Role"]>;
+export type RoleUpdate<T extends { Role: object }> = Updateable<T["Role"]>;
+
+export type UserRole<T extends { UserRole: object }> = Selectable<T["UserRole"]>;
+export type UserRoleCreate<T extends { UserRole: object }> = Insertable<T["UserRole"]>;
+export type UserRoleUpdate<T extends { UserRole: object }> = Updateable<T["UserRole"]>;
+
+export type RolePermission<T extends { RolePermission: object }> = Selectable<T["RolePermission"]>;
+export type RolePermissionCreate<T extends { RolePermission: object }> = Insertable<
+  T["RolePermission"]
+>;
+export type RolePermissionUpdate<T extends { RolePermission: object }> = Updateable<
+  T["RolePermission"]
+>;
+
+export type AuditEvent<T extends { AuditEvent: object }> = Selectable<T["AuditEvent"]>;
+export type AuditEventCreate<T extends { AuditEvent: object }> = Insertable<T["AuditEvent"]>;

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

@@ -0,0 +1,77 @@
+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 { createAuditEventType, CreateAuditEventTypeParams } from "./db/auditEvent";
+import { createPermissionType, CreatePermissionTypeParams } from "./db/permission";
+import { createRoleType, CreateRoleTypeParams } from "./db/role";
+import { createRolePermissionType, CreateRolePermissionTypeParams } from "./db/rolePermission";
+import { createUserType, CreateUserTypeParams } from "./db/user";
+import { createUserRoleType, CreateUserRoleTypeParams } from "./db/userRole";
+import {
+  recomputeOnRolePermissionCreated,
+  recomputeOnRolePermissionDeleted,
+} from "./executor/recomputeOnRolePermissionChange";
+
+export interface DefineModuleParams<
+  UF extends Record<string, TailorAnyDBField>,
+  RF extends Record<string, TailorAnyDBField>,
+  PF extends Record<string, TailorAnyDBField>,
+> {
+  dbNamespace: string;
+  user?: CreateUserTypeParams<UF>;
+  permission?: CreatePermissionTypeParams<PF>;
+  role?: CreateRoleTypeParams<RF>;
+  userRole?: CreateUserRoleTypeParams;
+  rolePermission?: CreateRolePermissionTypeParams;
+  auditEvent?: CreateAuditEventTypeParams;
+}
+
+export const defineModule = <
+  const UF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const RF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const PF extends Record<string, TailorAnyDBField> = EmptyFields,
+>(
+  params: DefineModuleParams<UF, RF, PF>,
+) => {
+  const user = createUserType(params.user ?? {});
+  const permission = createPermissionType(params.permission ?? {});
+  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,
+  });
+  const rolePermissionDeleted = recomputeOnRolePermissionDeleted({
+    namespace: params.dbNamespace,
+  });
+
+  return {
+    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,
+    },
+  };
+};

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

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

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

@@ -0,0 +1,11 @@
+import { defineConfig, defineGenerators } from "@tailor-platform/sdk";
+
+export default defineConfig({
+  name: "user-management",
+  db: { "main-db": { files: [`./src/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" }],
+);

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

@@ -0,0 +1,98 @@
+import type {
+  AuditEvent,
+  Permission,
+  Role,
+  RolePermission,
+  Schema,
+  User,
+  UserRole,
+} from "../lib/types";
+
+export const pendingUser = {
+  id: "user-pending-1",
+  email: "pending@example.com",
+  name: "Pending User",
+  status: "PENDING",
+  permissions: null,
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: null,
+} as const satisfies User<Schema>;
+
+export const activeUser = {
+  id: "user-active-1",
+  email: "active@example.com",
+  name: "Active User",
+  status: "ACTIVE",
+  permissions: null,
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: new Date("2024-01-02T00:00:00.000Z"),
+} as const satisfies User<Schema>;
+
+export const inactiveUser = {
+  id: "user-inactive-1",
+  email: "inactive@example.com",
+  name: "Inactive User",
+  status: "INACTIVE",
+  permissions: null,
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: new Date("2024-01-03T00:00:00.000Z"),
+} as const satisfies User<Schema>;
+
+export const basePermission = {
+  id: "permission-1",
+  key: "orders:read",
+  description: "Permission to read orders",
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: null,
+} as const satisfies Permission<Schema>;
+
+export const writePermission = {
+  id: "permission-2",
+  key: "orders:write",
+  description: "Permission to write orders",
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: null,
+} as const satisfies Permission<Schema>;
+
+export const baseRole = {
+  id: "role-1",
+  name: "Order Manager",
+  description: "Role for managing orders",
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: null,
+} as const satisfies Role<Schema>;
+
+export const adminRole = {
+  id: "role-2",
+  name: "Admin",
+  description: "Administrator role",
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: null,
+} as const satisfies Role<Schema>;
+
+export const baseUserRole = {
+  id: "user-role-1",
+  userId: "user-active-1",
+  roleId: "role-1",
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: null,
+} as const satisfies UserRole<Schema>;
+
+export const baseRolePermission = {
+  id: "role-permission-1",
+  roleId: "role-1",
+  permissionId: "permission-1",
+  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

@@ -0,0 +1,25 @@
+import path from "node:path";
+import { PACKAGE_ROOT } from "./util.js";
+
+const SCHEMAS_ROOT = path.join(PACKAGE_ROOT, "schemas");
+
+export const MODULE_SCHEMAS = {
+  module: path.join(SCHEMAS_ROOT, "module", "module.yml"),
+  command: path.join(SCHEMAS_ROOT, "module", "command.yml"),
+  model: path.join(SCHEMAS_ROOT, "module", "model.yml"),
+  feature: path.join(SCHEMAS_ROOT, "module", "feature.yml"),
+} as const;
+
+export const APP_COMPOSE_SCHEMAS = {
+  requirements: 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"),
+  screen: path.join(SCHEMAS_ROOT, "app-compose", "screen.yml"),
+  resolver: path.join(SCHEMAS_ROOT, "app-compose", "resolver.yml"),
+} as const;
+
+export const ALL_SCHEMAS: Record<string, string> = {
+  ...MODULE_SCHEMAS,
+  ...APP_COMPOSE_SCHEMAS,
+};

package/src/testing.ts

@@ -0,0 +1,10 @@
+export {
+  createMockDb,
+  testNotFound,
+  testPermissionDenied,
+  testIdempotent,
+  type Spy,
+  type QueryBuilder,
+  type MockDbSpies,
+} from "./modules/testing/index";
+export { createMockServer, type MockServer } from "./mockServer";

package/src/util.ts

@@ -0,0 +1,3 @@
+import path from "node:path";
+
+export const PACKAGE_ROOT = path.resolve(import.meta.dirname, "..");