@tailor-platform/erp-kit 0.5.1 → 0.7.0

package/src/modules/finance-ledger/command/verifySubledgerTransfers.test.ts

@@ -0,0 +1,201 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  PeriodCloseNotFoundError,
+  InvalidStatusTransitionError,
+  PendingSubledgerTransactionsError,
+} from "../lib/errors.generated";
+import {
+  basePeriodClose,
+  inProgressPeriodClose,
+  subledgersVerifiedPeriodClose,
+  baseJournalEntry,
+  baseAccountingPeriod,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./verifySubledgerTransfers";
+
+describe("verifySubledgerTransfers", () => {
+  it("returns error when PeriodClose record does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined); // PeriodClose lookup
+
+    const result = await run(db, { id: "nonexistent" }, commandCtx);
+
+    expectErr(result, PeriodCloseNotFoundError);
+  });
+
+  it("returns error when PeriodClose is in NOT_STARTED status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(basePeriodClose); // PeriodClose in NOT_STARTED
+
+    const result = await run(db, { id: basePeriodClose.id }, commandCtx);
+
+    expectErr(result, InvalidStatusTransitionError);
+  });
+
+  it("returns error when PeriodClose is already in SUBLEDGERS_VERIFIED status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(subledgersVerifiedPeriodClose); // PeriodClose in SUBLEDGERS_VERIFIED
+
+    const result = await run(db, { id: subledgersVerifiedPeriodClose.id }, commandCtx);
+
+    expectErr(result, InvalidStatusTransitionError);
+  });
+
+  it("returns error when purchase module has pending unposted transactions", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const purchaseDraft = {
+      ...baseJournalEntry,
+      id: "je-purchase-draft",
+      journalType: "PURCHASE",
+      accountingPeriodId: baseAccountingPeriod.id,
+      status: "DRAFT",
+    };
+    spies.select
+      .mockReturnValueOnce(inProgressPeriodClose) // PeriodClose lookup
+      .mockReturnValueOnce([purchaseDraft]) // purchase DRAFT entries
+      .mockReturnValueOnce([]) // sales: no pending
+      .mockReturnValueOnce([]) // inventory: no pending
+      .mockReturnValueOnce([]); // manufacturing: no pending
+
+    const result = await run(db, { id: inProgressPeriodClose.id }, commandCtx);
+
+    expectErr(result, PendingSubledgerTransactionsError);
+  });
+
+  it("returns error when sales module has pending unposted transactions", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const salesDraft = {
+      ...baseJournalEntry,
+      id: "je-sales-draft",
+      journalType: "SALES",
+      accountingPeriodId: baseAccountingPeriod.id,
+      status: "DRAFT",
+    };
+    spies.select
+      .mockReturnValueOnce(inProgressPeriodClose) // PeriodClose lookup
+      .mockReturnValueOnce([]) // purchase: no pending
+      .mockReturnValueOnce([salesDraft]) // sales: pending
+      .mockReturnValueOnce([]) // inventory: no pending
+      .mockReturnValueOnce([]); // manufacturing: no pending
+
+    const result = await run(db, { id: inProgressPeriodClose.id }, commandCtx);
+
+    expectErr(result, PendingSubledgerTransactionsError);
+  });
+
+  it("returns error when inventory module has pending unposted transactions", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const inventoryDraft = {
+      ...baseJournalEntry,
+      id: "je-inventory-draft",
+      journalType: "MISCELLANEOUS",
+      accountingPeriodId: baseAccountingPeriod.id,
+      status: "DRAFT",
+    };
+    spies.select
+      .mockReturnValueOnce(inProgressPeriodClose) // PeriodClose lookup
+      .mockReturnValueOnce([]) // purchase: no pending
+      .mockReturnValueOnce([]) // sales: no pending
+      .mockReturnValueOnce([inventoryDraft]) // inventory: pending
+      .mockReturnValueOnce([]); // manufacturing: no pending
+
+    const result = await run(db, { id: inProgressPeriodClose.id }, commandCtx);
+
+    expectErr(result, PendingSubledgerTransactionsError);
+  });
+
+  it("returns error when manufacturing module has pending unposted transactions", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const manufacturingDraft = {
+      ...baseJournalEntry,
+      id: "je-manufacturing-draft",
+      journalType: "MISCELLANEOUS",
+      accountingPeriodId: baseAccountingPeriod.id,
+      status: "DRAFT",
+    };
+    spies.select
+      .mockReturnValueOnce(inProgressPeriodClose) // PeriodClose lookup
+      .mockReturnValueOnce([]) // purchase: no pending
+      .mockReturnValueOnce([]) // sales: no pending
+      .mockReturnValueOnce([]) // inventory: no pending
+      .mockReturnValueOnce([manufacturingDraft]); // manufacturing: pending
+
+    const result = await run(db, { id: inProgressPeriodClose.id }, commandCtx);
+
+    expectErr(result, PendingSubledgerTransactionsError);
+  });
+
+  it("transitions IN_PROGRESS to SUBLEDGERS_VERIFIED when all subledgers are reconciled", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedPeriodClose = {
+      ...inProgressPeriodClose,
+      status: "SUBLEDGERS_VERIFIED",
+      completionPercentage: 25,
+    };
+    spies.select
+      .mockReturnValueOnce(inProgressPeriodClose) // PeriodClose lookup
+      .mockReturnValueOnce([]) // purchase: no pending
+      .mockReturnValueOnce([]) // sales: no pending
+      .mockReturnValueOnce([]) // inventory: no pending
+      .mockReturnValueOnce([]); // manufacturing: no pending
+    spies.update.mockReturnValueOnce(updatedPeriodClose);
+
+    const result = await run(db, { id: inProgressPeriodClose.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.periodClose.status).toBe("SUBLEDGERS_VERIFIED");
+  });
+
+  it("updates completionPercentage after successful verification", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedPeriodClose = {
+      ...inProgressPeriodClose,
+      status: "SUBLEDGERS_VERIFIED",
+      completionPercentage: 25,
+    };
+    spies.select
+      .mockReturnValueOnce(inProgressPeriodClose) // PeriodClose lookup
+      .mockReturnValueOnce([]) // purchase: no pending
+      .mockReturnValueOnce([]) // sales: no pending
+      .mockReturnValueOnce([]) // inventory: no pending
+      .mockReturnValueOnce([]); // manufacturing: no pending
+    spies.update.mockReturnValueOnce(updatedPeriodClose);
+
+    const result = await run(db, { id: inProgressPeriodClose.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.periodClose.completionPercentage).toBe(25);
+  });
+
+  it("emits audit event recording subledger verification results and status transition", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedPeriodClose = {
+      ...inProgressPeriodClose,
+      status: "SUBLEDGERS_VERIFIED",
+      completionPercentage: 25,
+    };
+    spies.select
+      .mockReturnValueOnce(inProgressPeriodClose) // PeriodClose lookup
+      .mockReturnValueOnce([]) // purchase: no pending
+      .mockReturnValueOnce([]) // sales: no pending
+      .mockReturnValueOnce([]) // inventory: no pending
+      .mockReturnValueOnce([]); // manufacturing: no pending
+    spies.update.mockReturnValueOnce(updatedPeriodClose);
+
+    const result = await run(db, { id: inProgressPeriodClose.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.auditEvent).toBeDefined();
+    expect(value.auditEvent.type).toBe("SUBLEDGER_VERIFICATION_COMPLETED");
+    expect(value.auditEvent.actorId).toBe(commandCtx.actorId);
+    expect(value.auditEvent.from).toBe("IN_PROGRESS");
+    expect(value.auditEvent.to).toBe("SUBLEDGERS_VERIFIED");
+    expect(value.auditEvent.verificationResults).toHaveLength(4);
+    expect(
+      value.auditEvent.verificationResults.every((r: { reconciled: boolean }) => r.reconciled),
+    ).toBe(true);
+  });
+});

package/src/modules/finance-ledger/command/verifySubledgerTransfers.ts

@@ -0,0 +1,113 @@
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  PeriodCloseNotFoundError,
+  InvalidStatusTransitionError,
+  PendingSubledgerTransactionsError,
+} from "../lib/errors.generated";
+
+export interface VerifySubledgerTransfersInput {
+  id: string;
+}
+
+interface SubledgerVerificationResult {
+  module: string;
+  journalType: string;
+  pendingCount: number;
+  reconciled: boolean;
+}
+
+const SUBLEDGER_MODULES: { module: string; journalType: string }[] = [
+  { module: "purchase", journalType: "PURCHASE" },
+  { module: "sales", journalType: "SALES" },
+  { module: "inventory", journalType: "MISCELLANEOUS" },
+  { module: "manufacturing", journalType: "MISCELLANEOUS" },
+];
+
+const SUBLEDGERS_VERIFIED_COMPLETION_PERCENTAGE = 25;
+
+/**
+ * Function: verifySubledgerTransfers
+ *
+ * Checks that all registered subledger modules have completed their
+ * transaction transfers to the general ledger for the closing period.
+ * If all subledgers are reconciled, the PeriodClose transitions from
+ * IN_PROGRESS to SUBLEDGERS_VERIFIED.
+ */
+export async function run(
+  db: Transaction,
+  input: VerifySubledgerTransfersInput,
+  ctx: CommandContext,
+) {
+  const { id } = input;
+
+  // 1. Find PeriodClose record
+  const periodClose = await db
+    .selectFrom("PeriodClose")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!periodClose) {
+    return err(new PeriodCloseNotFoundError(id));
+  }
+
+  // 2. Validate PeriodClose is in IN_PROGRESS status
+  if (periodClose.status !== "IN_PROGRESS") {
+    return err(new InvalidStatusTransitionError(id));
+  }
+
+  // 3. Check all registered subledger modules for pending unposted transactions
+  const verificationResults: SubledgerVerificationResult[] = [];
+
+  for (const subledger of SUBLEDGER_MODULES) {
+    const pendingEntries = await db
+      .selectFrom("JournalEntry")
+      .selectAll()
+      .where("accountingPeriodId", "=", periodClose.accountingPeriodId)
+      .where("journalType", "=", subledger.journalType as "PURCHASE" | "SALES" | "MISCELLANEOUS")
+      .where("status", "=", "DRAFT")
+      .execute();
+
+    verificationResults.push({
+      module: subledger.module,
+      journalType: subledger.journalType,
+      pendingCount: pendingEntries.length,
+      reconciled: pendingEntries.length === 0,
+    });
+  }
+
+  // 4. If any subledger has pending transactions, fail
+  const pendingModules = verificationResults.filter((r) => !r.reconciled);
+  if (pendingModules.length > 0) {
+    return err(new PendingSubledgerTransactionsError(id));
+  }
+
+  // 5. Transition PeriodClose to SUBLEDGERS_VERIFIED and update completionPercentage
+  const now = new Date();
+  const updatedPeriodClose = await db
+    .updateTable("PeriodClose")
+    .set({
+      status: "SUBLEDGERS_VERIFIED",
+      completionPercentage: SUBLEDGERS_VERIFIED_COMPLETION_PERCENTAGE,
+      subledgerVerificationDetails: JSON.stringify(verificationResults),
+      updatedAt: now,
+    })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  // 6. Emit audit event
+  const auditEvent = {
+    type: "SUBLEDGER_VERIFICATION_COMPLETED",
+    actorId: ctx.actorId,
+    timestamp: now,
+    periodCloseId: id,
+    from: "IN_PROGRESS",
+    to: "SUBLEDGERS_VERIFIED",
+    verificationResults,
+  };
+
+  return ok({ periodClose: updatedPeriodClose!, auditEvent });
+}

package/src/modules/finance-ledger/command/verifyTrialBalance.generated.ts

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

package/src/modules/finance-ledger/command/verifyTrialBalance.test.ts

@@ -0,0 +1,136 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  PeriodCloseNotFoundError,
+  InvalidStatusTransitionError,
+  TrialBalanceImbalancedError,
+} from "../lib/errors.generated";
+import {
+  adjustmentsPostedPeriodClose,
+  subledgersVerifiedPeriodClose,
+  trialBalanceVerifiedPeriodClose,
+  baseTrialBalance,
+  baseAccountingPeriod,
+  baseChartOfAccounts,
+} from "../testing/fixtures";
+import { commandCtx, expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./verifyTrialBalance";
+
+describe("verifyTrialBalance", () => {
+  it("returns error when PeriodClose record does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined); // PeriodClose lookup
+
+    const result = await run(db, { id: "nonexistent" }, commandCtx);
+
+    expectErr(result, PeriodCloseNotFoundError);
+  });
+
+  it("returns error when PeriodClose is in SUBLEDGERS_VERIFIED status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(subledgersVerifiedPeriodClose); // PeriodClose lookup
+
+    const result = await run(db, { id: subledgersVerifiedPeriodClose.id }, commandCtx);
+
+    expectErr(result, InvalidStatusTransitionError);
+  });
+
+  it("returns error when PeriodClose is already in TRIAL_BALANCE_VERIFIED status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(trialBalanceVerifiedPeriodClose); // PeriodClose lookup
+
+    const result = await run(db, { id: trialBalanceVerifiedPeriodClose.id }, commandCtx);
+
+    expectErr(result, InvalidStatusTransitionError);
+  });
+
+  it("returns error when trial balance has a non-zero debit-credit discrepancy", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const imbalancedTrialBalance = {
+      ...baseTrialBalance,
+      id: "trial-balance-imbalanced",
+      totalDebits: 10000,
+      totalCredits: 9500,
+      isBalanced: false,
+    };
+    spies.select
+      .mockReturnValueOnce(adjustmentsPostedPeriodClose) // PeriodClose lookup
+      .mockReturnValueOnce(baseAccountingPeriod) // AccountingPeriod lookup
+      .mockReturnValueOnce(baseChartOfAccounts) // ChartOfAccounts lookup
+      .mockReturnValueOnce(imbalancedTrialBalance); // TrialBalance lookup
+
+    const result = await run(db, { id: adjustmentsPostedPeriodClose.id }, commandCtx);
+
+    expectErr(result, TrialBalanceImbalancedError);
+  });
+
+  it("transitions ADJUSTMENTS_POSTED to TRIAL_BALANCE_VERIFIED when trial balance is balanced", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedPeriodClose = {
+      ...adjustmentsPostedPeriodClose,
+      status: "TRIAL_BALANCE_VERIFIED",
+      trialBalanceId: baseTrialBalance.id,
+      completionPercentage: 62,
+    };
+    spies.select
+      .mockReturnValueOnce(adjustmentsPostedPeriodClose) // PeriodClose lookup
+      .mockReturnValueOnce(baseAccountingPeriod) // AccountingPeriod lookup
+      .mockReturnValueOnce(baseChartOfAccounts) // ChartOfAccounts lookup
+      .mockReturnValueOnce(baseTrialBalance); // TrialBalance lookup (balanced)
+    spies.update.mockReturnValueOnce(updatedPeriodClose);
+
+    const result = await run(db, { id: adjustmentsPostedPeriodClose.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.periodClose.status).toBe("TRIAL_BALANCE_VERIFIED");
+  });
+
+  it("updates completionPercentage after successful verification", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedPeriodClose = {
+      ...adjustmentsPostedPeriodClose,
+      status: "TRIAL_BALANCE_VERIFIED",
+      trialBalanceId: baseTrialBalance.id,
+      completionPercentage: 62,
+    };
+    spies.select
+      .mockReturnValueOnce(adjustmentsPostedPeriodClose) // PeriodClose lookup
+      .mockReturnValueOnce(baseAccountingPeriod) // AccountingPeriod lookup
+      .mockReturnValueOnce(baseChartOfAccounts) // ChartOfAccounts lookup
+      .mockReturnValueOnce(baseTrialBalance); // TrialBalance lookup (balanced)
+    spies.update.mockReturnValueOnce(updatedPeriodClose);
+
+    const result = await run(db, { id: adjustmentsPostedPeriodClose.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.periodClose.completionPercentage).toBe(62);
+  });
+
+  it("emits audit event recording trial balance result and status transition", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedPeriodClose = {
+      ...adjustmentsPostedPeriodClose,
+      status: "TRIAL_BALANCE_VERIFIED",
+      trialBalanceId: baseTrialBalance.id,
+      completionPercentage: 62,
+    };
+    spies.select
+      .mockReturnValueOnce(adjustmentsPostedPeriodClose) // PeriodClose lookup
+      .mockReturnValueOnce(baseAccountingPeriod) // AccountingPeriod lookup
+      .mockReturnValueOnce(baseChartOfAccounts) // ChartOfAccounts lookup
+      .mockReturnValueOnce(baseTrialBalance); // TrialBalance lookup (balanced)
+    spies.update.mockReturnValueOnce(updatedPeriodClose);
+
+    const result = await run(db, { id: adjustmentsPostedPeriodClose.id }, commandCtx);
+
+    const value = expectOk(result);
+    expect(value.auditEvent).toBeDefined();
+    expect(value.auditEvent.actorId).toBe(commandCtx.actorId);
+    expect(value.auditEvent.timestamp).toBeInstanceOf(Date);
+    expect(value.auditEvent.from).toBe("ADJUSTMENTS_POSTED");
+    expect(value.auditEvent.to).toBe("TRIAL_BALANCE_VERIFIED");
+    expect(value.auditEvent.trialBalanceId).toBe(baseTrialBalance.id);
+    expect(value.auditEvent.isBalanced).toBe(true);
+  });
+});

package/src/modules/finance-ledger/command/verifyTrialBalance.ts

@@ -0,0 +1,97 @@
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  PeriodCloseNotFoundError,
+  InvalidStatusTransitionError,
+  TrialBalanceImbalancedError,
+} from "../lib/errors.generated";
+
+export interface VerifyTrialBalanceInput {
+  id: string;
+}
+
+/**
+ * Function: verifyTrialBalance
+ *
+ * Checks that the period's trial balance is balanced (total debits equal total
+ * credits across all accounts) and transitions the PeriodClose from
+ * ADJUSTMENTS_POSTED to TRIAL_BALANCE_VERIFIED status.
+ */
+export async function run(db: Transaction, input: VerifyTrialBalanceInput, ctx: CommandContext) {
+  const { id } = input;
+
+  // 1. Find PeriodClose record
+  const periodClose = await db
+    .selectFrom("PeriodClose")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!periodClose) {
+    return err(new PeriodCloseNotFoundError(id));
+  }
+
+  // 2. Validate status is ADJUSTMENTS_POSTED
+  if (periodClose.status !== "ADJUSTMENTS_POSTED") {
+    return err(new InvalidStatusTransitionError(id));
+  }
+
+  // 3. Retrieve the accounting period to find the company and period context
+  const accountingPeriod = await db
+    .selectFrom("AccountingPeriod")
+    .selectAll()
+    .where("id", "=", periodClose.accountingPeriodId)
+    .executeTakeFirst();
+
+  // 4. Retrieve the active chart of accounts for trial balance generation
+  const chartOfAccounts = await db
+    .selectFrom("ChartOfAccounts")
+    .selectAll()
+    .where("companyId", "=", accountingPeriod!.companyId)
+    .where("status", "=", "ACTIVE")
+    .executeTakeFirst();
+
+  // 5. Generate or retrieve the trial balance for the period
+  const trialBalance = await db
+    .selectFrom("TrialBalance")
+    .selectAll()
+    .where("accountingPeriodId", "=", periodClose.accountingPeriodId)
+    .where("chartOfAccountsId", "=", chartOfAccounts!.id)
+    .executeTakeFirst();
+
+  // 6. Verify trial balance is balanced
+  if (!trialBalance || trialBalance.totalDebits !== trialBalance.totalCredits) {
+    const discrepancy = trialBalance
+      ? Math.abs(trialBalance.totalDebits - trialBalance.totalCredits)
+      : 0;
+    return err(new TrialBalanceImbalancedError(`${id} (discrepancy: ${discrepancy})`));
+  }
+
+  // 7. Transition PeriodClose to TRIAL_BALANCE_VERIFIED and update completionPercentage
+  const now = new Date();
+  const updated = await db
+    .updateTable("PeriodClose")
+    .set({
+      status: "TRIAL_BALANCE_VERIFIED",
+      trialBalanceId: trialBalance.id,
+      completionPercentage: 62,
+      updatedAt: now,
+    })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  // 8. Emit audit event
+  const auditEvent = {
+    type: "TRIAL_BALANCE_VERIFIED",
+    from: "ADJUSTMENTS_POSTED",
+    to: "TRIAL_BALANCE_VERIFIED",
+    actorId: ctx.actorId,
+    timestamp: now,
+    trialBalanceId: trialBalance.id,
+    isBalanced: true,
+  };
+
+  return ok({ periodClose: updated, auditEvent });
+}

package/src/modules/finance-ledger/db/accountingPeriod.ts

@@ -0,0 +1,58 @@
+import {
+  db,
+  type TailorAnyDBField,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { company as companyStub } from "../lib/_db_deps";
+import { fiscalYear } from "./fiscalYear";
+
+export const ACCOUNTING_PERIOD_STATUSES: [string, string, string, string, string] = [
+  "NEVER_OPENED",
+  "FUTURE_ENTERABLE",
+  "OPEN",
+  "CLOSED",
+  "PERMANENTLY_CLOSED",
+];
+
+export interface CreateAccountingPeriodTypeParams<F extends Record<string, TailorAnyDBField>> {
+  fields?: F;
+  companyType?: TailorAnyDBType;
+  fiscalYearType?: TailorAnyDBType;
+}
+
+export function createAccountingPeriodType<const F extends Record<string, TailorAnyDBField>>(
+  params: CreateAccountingPeriodTypeParams<F>,
+) {
+  return db
+    .type("AccountingPeriod", {
+      companyId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.companyType ?? companyStub },
+          backward: "accountingPeriods",
+        })
+        .description("Foreign key to Company"),
+      fiscalYearId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.fiscalYearType ?? fiscalYear },
+          backward: "accountingPeriods",
+        })
+        .description("Foreign key to FiscalYear"),
+      name: db.string().description("Period name"),
+      startDate: db.date().description("Period start date"),
+      endDate: db.date().description("Period end date"),
+      periodType: db.enum(["OPERATING", "ADJUSTMENT"]).description("Period type"),
+      status: db.enum(ACCOUNTING_PERIOD_STATUSES).description("Accounting period lifecycle status"),
+      ...((params.fields ?? {}) as F),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const accountingPeriod = createAccountingPeriodType({});