@tailor-platform/erp-kit 0.7.0 → 0.8.0

package/src/modules/accounting/command/updateInternalOrder.ts

@@ -0,0 +1,88 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  InternalOrderNotFoundError,
+  InvalidStateError,
+  OrderTypeChangeNotAllowedError,
+  CostCenterNotFoundError,
+  InvalidValidityPeriodError,
+} from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export type UpdateInternalOrderInput = {
+  internalOrderId: string;
+  description?: string;
+  responsiblePersonId?: string;
+  costCenterId?: string;
+  orderType?: string;
+  validFrom?: Date | null;
+  validTo?: Date | null;
+};
+export async function run(db: Transaction, input: UpdateInternalOrderInput, ctx: CommandContext) {
+  void ctx;
+
+  // Fetch internal order
+  const order = await db
+    .selectFrom("InternalOrder")
+    .selectAll()
+    .where("id", "=", input.internalOrderId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!order) {
+    return err(new InternalOrderNotFoundError(input.internalOrderId));
+  }
+
+  // Validate status allows update
+  if (!["CREATED", "RELEASED"].includes(order.status)) {
+    return err(new InvalidStateError(input.internalOrderId));
+  }
+
+  // Order type cannot change after release
+  if (
+    input.orderType !== undefined &&
+    order.status === "RELEASED" &&
+    input.orderType !== order.orderType
+  ) {
+    return err(new OrderTypeChangeNotAllowedError(input.internalOrderId));
+  }
+
+  // Validate cost center if changed
+  if (input.costCenterId !== undefined) {
+    const costCenter = await db
+      .selectFrom("CostCenter")
+      .where("id", "=", input.costCenterId)
+      .where("companyId", "=", order.companyId)
+      .selectAll()
+      .executeTakeFirst();
+
+    if (!costCenter) {
+      return err(new CostCenterNotFoundError(input.costCenterId));
+    }
+  }
+
+  // Validate validity dates
+  const newValidFrom = input.validFrom !== undefined ? input.validFrom : order.validFrom;
+  const newValidTo = input.validTo !== undefined ? input.validTo : order.validTo;
+  if (newValidFrom && newValidTo && newValidFrom > newValidTo) {
+    return err(new InvalidValidityPeriodError(input.internalOrderId));
+  }
+
+  // Build update set
+  const updates: Record<string, unknown> = { updatedAt: new Date() };
+  if (input.description !== undefined) updates.description = input.description;
+  if (input.responsiblePersonId !== undefined)
+    updates.responsiblePersonId = input.responsiblePersonId;
+  if (input.costCenterId !== undefined) updates.costCenterId = input.costCenterId;
+  if (input.orderType !== undefined) updates.orderType = input.orderType;
+  if (input.validFrom !== undefined) updates.validFrom = input.validFrom;
+  if (input.validTo !== undefined) updates.validTo = input.validTo;
+
+  const updated = await db
+    .updateTable("InternalOrder")
+    .set(updates)
+    .where("id", "=", input.internalOrderId)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ internalOrder: updated! });
+}

package/src/modules/accounting/command/updateProfitCenter.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./updateProfitCenter";
+import { defineCommand } from "@tailor-platform/erp-kit/module";
+
+export const updateProfitCenter = defineCommand(permissions.updateProfitCenter, run);

package/src/modules/accounting/command/updateProfitCenter.test.ts

@@ -0,0 +1,162 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  ProfitCenterNotFoundError,
+  InvalidStateError,
+  FieldNotUpdatableError,
+  InvalidValidityPeriodError,
+} from "../lib/errors.generated";
+import { baseProfitCenter, activeProfitCenter, inactiveProfitCenter } from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./updateProfitCenter";
+
+describe("updateProfitCenter", () => {
+  it("updates name on a DRAFT profit center", async () => {
+    const updated = { ...baseProfitCenter, name: "New Name" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseProfitCenter);
+    spies.update.mockReturnValueOnce(updated);
+
+    const result = await run(
+      db,
+      { profitCenterId: baseProfitCenter.id, name: "New Name" },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.profitCenter.name).toBe("New Name");
+  });
+
+  it("updates description on a DRAFT profit center", async () => {
+    const updated = { ...baseProfitCenter, description: "Updated desc" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseProfitCenter);
+    spies.update.mockReturnValueOnce(updated);
+
+    const result = await run(
+      db,
+      { profitCenterId: baseProfitCenter.id, description: "Updated desc" },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.profitCenter.description).toBe("Updated desc");
+  });
+
+  it("updates description on an ACTIVE profit center", async () => {
+    const updated = { ...activeProfitCenter, description: "Active desc" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeProfitCenter);
+    spies.update.mockReturnValueOnce(updated);
+
+    const result = await run(
+      db,
+      { profitCenterId: activeProfitCenter.id, description: "Active desc" },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.profitCenter.description).toBe("Active desc");
+  });
+
+  it("updates responsible person on a DRAFT profit center", async () => {
+    const updated = { ...baseProfitCenter, responsiblePersonId: "user-2" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseProfitCenter);
+    spies.update.mockReturnValueOnce(updated);
+
+    const result = await run(
+      db,
+      { profitCenterId: baseProfitCenter.id, responsiblePersonId: "user-2" },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.profitCenter.responsiblePersonId).toBe("user-2");
+  });
+
+  it("updates responsible person on an ACTIVE profit center", async () => {
+    const updated = { ...activeProfitCenter, responsiblePersonId: "user-2" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeProfitCenter);
+    spies.update.mockReturnValueOnce(updated);
+
+    const result = await run(
+      db,
+      { profitCenterId: activeProfitCenter.id, responsiblePersonId: "user-2" },
+      commandCtx,
+    );
+
+    const value = expectOk(result);
+    expect(value.profitCenter.responsiblePersonId).toBe("user-2");
+  });
+
+  it("returns error when changing restricted fields on an ACTIVE profit center", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(activeProfitCenter);
+
+    const result = await run(
+      db,
+      { profitCenterId: activeProfitCenter.id, name: "New Name" },
+      commandCtx,
+    );
+
+    expectErr(result, FieldNotUpdatableError);
+  });
+
+  it("returns error when profit center does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { profitCenterId: "missing-id" }, commandCtx);
+
+    expectErr(result, ProfitCenterNotFoundError);
+  });
+
+  it("returns error when profit center is INACTIVE", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(inactiveProfitCenter);
+
+    const result = await run(
+      db,
+      { profitCenterId: inactiveProfitCenter.id, description: "test" },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when validTo is before validFrom", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseProfitCenter);
+
+    const result = await run(
+      db,
+      {
+        profitCenterId: baseProfitCenter.id,
+        validFrom: new Date("2024-06-01"),
+        validTo: new Date("2024-01-01"),
+      },
+      commandCtx,
+    );
+
+    expectErr(result, InvalidValidityPeriodError);
+  });
+
+  it("emits audit event recording previous and new field values", async () => {
+    const updated = { ...baseProfitCenter, description: "New" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseProfitCenter);
+    spies.update.mockReturnValueOnce(updated);
+
+    const result = await run(
+      db,
+      { profitCenterId: baseProfitCenter.id, description: "New" },
+      commandCtx,
+    );
+
+    expectOk(result);
+    expect(spies.update).toHaveBeenCalled();
+  });
+});

package/src/modules/accounting/command/updateProfitCenter.ts

@@ -0,0 +1,73 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  ProfitCenterNotFoundError,
+  InvalidStateError,
+  FieldNotUpdatableError,
+  InvalidValidityPeriodError,
+} from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export type UpdateProfitCenterInput = { profitCenterId: string } & {
+  name?: string;
+  description?: string | null;
+  responsiblePersonId?: string | null;
+  validFrom?: Date;
+  validTo?: Date | null;
+};
+export async function run(db: Transaction, input: UpdateProfitCenterInput, ctx: CommandContext) {
+  void ctx;
+
+  // Validate profit center exists
+  const profitCenter = await db
+    .selectFrom("ProfitCenter")
+    .selectAll()
+    .where("id", "=", input.profitCenterId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!profitCenter) {
+    return err(new ProfitCenterNotFoundError(input.profitCenterId));
+  }
+
+  // Validate status is DRAFT or ACTIVE
+  if (!["DRAFT", "ACTIVE"].includes(profitCenter.status)) {
+    return err(new InvalidStateError(profitCenter.id));
+  }
+
+  // In ACTIVE status, only description and responsiblePersonId can be updated
+  if (profitCenter.status === "ACTIVE") {
+    const restrictedFields: (keyof UpdateProfitCenterInput)[] = ["name", "validFrom", "validTo"];
+    for (const field of restrictedFields) {
+      if (input[field] !== undefined) {
+        return err(new FieldNotUpdatableError(profitCenter.id));
+      }
+    }
+  }
+
+  // Determine the effective validFrom and validTo for validation
+  const effectiveValidFrom = input.validFrom ?? profitCenter.validFrom;
+  const effectiveValidTo = input.validTo !== undefined ? input.validTo : profitCenter.validTo;
+
+  // Validate validTo >= validFrom when both are set
+  if (effectiveValidTo && effectiveValidFrom && effectiveValidTo < effectiveValidFrom) {
+    return err(new InvalidValidityPeriodError(profitCenter.id));
+  }
+
+  // Build the update set
+  const updateSet: Record<string, unknown> = { updatedAt: new Date() };
+  if (input.name !== undefined) updateSet.name = input.name;
+  if (input.description !== undefined) updateSet.description = input.description;
+  if (input.responsiblePersonId !== undefined)
+    updateSet.responsiblePersonId = input.responsiblePersonId;
+  if (input.validFrom !== undefined) updateSet.validFrom = input.validFrom;
+  if (input.validTo !== undefined) updateSet.validTo = input.validTo;
+
+  const updated = await db
+    .updateTable("ProfitCenter")
+    .set(updateSet)
+    .where("id", "=", profitCenter.id)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ profitCenter: updated! });
+}

package/src/modules/accounting/command/validateAllocationCycle.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./validateAllocationCycle";
+import { defineCommand } from "@tailor-platform/erp-kit/module";
+
+export const validateAllocationCycle = defineCommand(permissions.validateAllocationCycle, run);

package/src/modules/accounting/command/validateAllocationCycle.test.ts

@@ -0,0 +1,141 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  AllocationCycleNotFoundError,
+  InvalidStateError,
+  NoAllocationRulesError,
+  InvalidPercentageError,
+  InvalidPercentageSumError,
+} from "../lib/errors.generated";
+import {
+  baseAllocationCycle,
+  baseAllocationRule,
+  validatedAllocationCycle,
+  baseCostCenter,
+  baseCostCenter2,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./validateAllocationCycle";
+
+describe("validateAllocationCycle", () => {
+  it("validates a DRAFT allocation cycle with valid rules transitioning it to VALIDATED status", async () => {
+    const validated = { ...baseAllocationCycle, status: "VALIDATED" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseAllocationCycle) // cycle lookup
+      .mockReturnValueOnce([baseAllocationRule]); // rules lookup (execute returns array)
+    spies.update.mockReturnValueOnce(validated);
+
+    const result = await run(db, { allocationCycleId: baseAllocationCycle.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.allocationCycle.status).toBe("VALIDATED");
+  });
+
+  it("returns error when allocation cycle does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { allocationCycleId: "missing-id" }, commandCtx);
+
+    expectErr(result, AllocationCycleNotFoundError);
+  });
+
+  it("returns error when allocation cycle is not in DRAFT status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(validatedAllocationCycle);
+
+    const result = await run(db, { allocationCycleId: validatedAllocationCycle.id }, commandCtx);
+
+    expectErr(result, InvalidStateError);
+  });
+
+  it("returns error when cycle has no allocation rules", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseAllocationCycle) // cycle
+      .mockReturnValueOnce([]); // no rules
+
+    const result = await run(db, { allocationCycleId: baseAllocationCycle.id }, commandCtx);
+
+    expectErr(result, NoAllocationRulesError);
+  });
+
+  it("returns error when percentages do not sum to 100% for a sender", async () => {
+    const partialRule = { ...baseAllocationRule, percentage: 50 };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseAllocationCycle) // cycle
+      .mockReturnValueOnce([partialRule]); // rules with 50% only
+
+    const result = await run(db, { allocationCycleId: baseAllocationCycle.id }, commandCtx);
+
+    expectErr(result, InvalidPercentageSumError);
+  });
+
+  it("returns error when any percentage is zero or negative", async () => {
+    const invalidRule = { ...baseAllocationRule, percentage: -50 };
+    const offsetRule = {
+      ...baseAllocationRule,
+      id: "rule-offset",
+      receiverId: baseCostCenter2.id,
+      percentage: 150,
+    };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseAllocationCycle)
+      .mockReturnValueOnce([invalidRule, offsetRule]);
+
+    const result = await run(db, { allocationCycleId: baseAllocationCycle.id }, commandCtx);
+
+    expectErr(result, InvalidPercentageError);
+  });
+
+  it("validates with multiple senders each summing to 100%", async () => {
+    const rule1 = {
+      ...baseAllocationRule,
+      id: "rule-1",
+      senderCostCenterId: baseCostCenter.id,
+      receiverId: baseCostCenter2.id,
+      percentage: 100,
+    };
+    const rule2 = {
+      ...baseAllocationRule,
+      id: "rule-2",
+      senderCostCenterId: baseCostCenter2.id,
+      receiverId: baseCostCenter.id,
+      percentage: 60,
+    };
+    const rule3 = {
+      ...baseAllocationRule,
+      id: "rule-3",
+      senderCostCenterId: baseCostCenter2.id,
+      receiverId: baseCostCenter.id,
+      percentage: 40,
+    };
+    const validated = { ...baseAllocationCycle, status: "VALIDATED" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseAllocationCycle)
+      .mockReturnValueOnce([rule1, rule2, rule3]);
+    spies.update.mockReturnValueOnce(validated);
+
+    const result = await run(db, { allocationCycleId: baseAllocationCycle.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.allocationCycle.status).toBe("VALIDATED");
+  });
+
+  it("emits audit event recording the status transition and acting user", async () => {
+    const validated = { ...baseAllocationCycle, status: "VALIDATED" };
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseAllocationCycle).mockReturnValueOnce([baseAllocationRule]);
+    spies.update.mockReturnValueOnce(validated);
+
+    const result = await run(db, { allocationCycleId: baseAllocationCycle.id }, commandCtx);
+
+    expectOk(result);
+    expect(spies.update).toHaveBeenCalled();
+  });
+});

package/src/modules/accounting/command/validateAllocationCycle.ts

@@ -0,0 +1,80 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  AllocationCycleNotFoundError,
+  InvalidStateError,
+  NoAllocationRulesError,
+  InvalidPercentageError,
+  InvalidPercentageSumError,
+} from "../lib/errors.generated";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface ValidateAllocationCycleInput {
+  allocationCycleId: string;
+}
+
+export async function run(
+  db: Transaction,
+  input: ValidateAllocationCycleInput,
+  ctx: CommandContext,
+) {
+  void ctx;
+
+  // Validate allocation cycle exists
+  const cycle = await db
+    .selectFrom("AllocationCycle")
+    .where("id", "=", input.allocationCycleId)
+    .selectAll()
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!cycle) {
+    return err(new AllocationCycleNotFoundError(input.allocationCycleId));
+  }
+
+  // Validate status is DRAFT
+  if (cycle.status !== "DRAFT") {
+    return err(new InvalidStateError(input.allocationCycleId));
+  }
+
+  // Fetch all rules for this cycle
+  const rules = await db
+    .selectFrom("AllocationRule")
+    .selectAll()
+    .where("allocationCycleId", "=", input.allocationCycleId)
+    .execute();
+
+  if (!rules || (rules as unknown[]).length === 0) {
+    return err(new NoAllocationRulesError(input.allocationCycleId));
+  }
+
+  // Validate percentages sum to 100% per sender
+  const senderSums = new Map<string, number>();
+  for (const rule of rules as { senderCostCenterId: string; percentage: number }[]) {
+    if (rule.percentage <= 0) {
+      return err(new InvalidPercentageError(rule.senderCostCenterId));
+    }
+
+    senderSums.set(
+      rule.senderCostCenterId,
+      (senderSums.get(rule.senderCostCenterId) ?? 0) + rule.percentage,
+    );
+  }
+  for (const [senderId, sum] of senderSums) {
+    if (Math.abs(sum - 100) > 0.001) {
+      return err(new InvalidPercentageSumError(senderId));
+    }
+  }
+
+  // Transition to VALIDATED
+  const allocationCycle = await db
+    .updateTable("AllocationCycle")
+    .set({
+      status: "VALIDATED",
+      updatedAt: new Date(),
+    })
+    .where("id", "=", input.allocationCycleId)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ allocationCycle: allocationCycle! });
+}

package/src/modules/accounting/db/allocationCycle.ts

@@ -0,0 +1,59 @@
+import {
+  db,
+  type TailorAnyDBField,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { accountingPeriod as accountingPeriodStub, company as companyStub } from "../lib/_db_deps";
+
+export const ALLOCATION_CYCLE_STATUSES = [
+  "DRAFT",
+  "VALIDATED",
+  "EXECUTED",
+  "POSTED",
+  "REVERSED",
+] as const;
+
+export const ALLOCATION_TYPES = ["ASSESSMENT", "DISTRIBUTION"] as const;
+
+export interface CreateAllocationCycleTypeParams<F extends Record<string, TailorAnyDBField>> {
+  fields?: F;
+  companyType?: TailorAnyDBType;
+  accountingPeriodType?: TailorAnyDBType;
+}
+
+export function createAllocationCycleType<const F extends Record<string, TailorAnyDBField>>(
+  params: CreateAllocationCycleTypeParams<F>,
+) {
+  return db
+    .type("AllocationCycle", {
+      name: db.string().description("Allocation cycle name"),
+      allocationType: db.enum([...ALLOCATION_TYPES]).description("Allocation type"),
+      companyId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.companyType ?? companyStub },
+          backward: "allocationCycles",
+        })
+        .description("Foreign key to Company"),
+      accountingPeriodId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.accountingPeriodType ?? accountingPeriodStub },
+          backward: "allocationCycles",
+        })
+        .description("Foreign key to AccountingPeriod"),
+      status: db
+        .enum([...ALLOCATION_CYCLE_STATUSES])
+        .description("Allocation cycle lifecycle status"),
+      ...((params.fields ?? {}) as F),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const allocationCycle = createAllocationCycleType({});

package/src/modules/accounting/db/allocationResult.ts

@@ -0,0 +1,58 @@
+import {
+  db,
+  type TailorAnyDBField,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { allocationCycle } from "./allocationCycle";
+import { costCenter } from "./costCenter";
+import { costElement } from "./costElement";
+
+export interface CreateAllocationResultTypeParams<F extends Record<string, TailorAnyDBField>> {
+  fields?: F;
+  allocationCycleType?: TailorAnyDBType;
+  costCenterType?: TailorAnyDBType;
+  costElementType?: TailorAnyDBType;
+}
+
+export function createAllocationResultType<const F extends Record<string, TailorAnyDBField>>(
+  params: CreateAllocationResultTypeParams<F>,
+) {
+  return db
+    .type("AllocationResult", {
+      allocationCycleId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.allocationCycleType ?? allocationCycle },
+          backward: "results",
+        })
+        .description("Foreign key to AllocationCycle"),
+      senderCostCenterId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.costCenterType ?? costCenter },
+          backward: "allocationResultsAsSender",
+        })
+        .description("Foreign key to CostCenter (sender)"),
+      receiverType: db.string().description("Polymorphic receiver type"),
+      receiverId: db.uuid().description("Polymorphic receiver ID"),
+      allocatedAmount: db.float().description("Allocated amount"),
+      costElementId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.costElementType ?? costElement },
+          backward: "allocationResults",
+        })
+        .description("Foreign key to CostElement"),
+      ...((params.fields ?? {}) as F),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const allocationResult = createAllocationResultType({});