@tailor-platform/erp-kit 0.6.0 → 0.8.0

package/src/modules/finance-ledger/module.ts

@@ -0,0 +1,262 @@
+import type { TailorAnyDBField } from "@tailor-platform/sdk";
+import { type EmptyFields } from "@tailor-platform/erp-kit/module";
+import type { defineModule as defineCoaManagementModule } from "../coa-management";
+import type { defineModule as defineOrganizationModule } from "../organization";
+import type { defineModule as definePrimitivesModule } from "../primitives";
+import type { defineModule as defineUserManagementModule } from "../user-management";
+import { addJournalLine } from "./command/addJournalLine.generated";
+import { approveAndLockPeriod } from "./command/approveAndLockPeriod.generated";
+import { beginClose } from "./command/beginClose.generated";
+import { closePeriod } from "./command/closePeriod.generated";
+import { createAccountingPeriod } from "./command/createAccountingPeriod.generated";
+import { createFiscalYear } from "./command/createFiscalYear.generated";
+import { createJournalEntry } from "./command/createJournalEntry.generated";
+import { deleteAccountingPeriod } from "./command/deleteAccountingPeriod.generated";
+import { deleteFiscalYear } from "./command/deleteFiscalYear.generated";
+import { deleteJournalEntry } from "./command/deleteJournalEntry.generated";
+import { executeYearEndClose } from "./command/executeYearEndClose.generated";
+import { finalCloseAndLockPeriod } from "./command/finalCloseAndLockPeriod.generated";
+import { finalizeFinancialStatement } from "./command/finalizeFinancialStatement.generated";
+import { generateFinancialStatement } from "./command/generateFinancialStatement.generated";
+import { generatePreliminaryStatements } from "./command/generatePreliminaryStatements.generated";
+import { generateTrialBalance } from "./command/generateTrialBalance.generated";
+import { initiatePeriodClose } from "./command/initiatePeriodClose.generated";
+import { openForAdvanceEntry } from "./command/openForAdvanceEntry.generated";
+import { openPeriod } from "./command/openPeriod.generated";
+import { permanentlyClosePeriod } from "./command/permanentlyClosePeriod.generated";
+import { postAdjustingEntries } from "./command/postAdjustingEntries.generated";
+import { postJournalEntry } from "./command/postJournalEntry.generated";
+import { processInventoryHandoff } from "./command/processInventoryHandoff.generated";
+import { processManufacturingHandoff } from "./command/processManufacturingHandoff.generated";
+import { processPurchaseHandoff } from "./command/processPurchaseHandoff.generated";
+import { processSalesHandoff } from "./command/processSalesHandoff.generated";
+import { regenerateFinancialStatement } from "./command/regenerateFinancialStatement.generated";
+import { removeJournalLine } from "./command/removeJournalLine.generated";
+import { reopenPeriod } from "./command/reopenPeriod.generated";
+import { reverseJournalEntry } from "./command/reverseJournalEntry.generated";
+import { revertSoftLock } from "./command/revertSoftLock.generated";
+import { updateFiscalYear } from "./command/updateFiscalYear.generated";
+import { updateJournalEntry } from "./command/updateJournalEntry.generated";
+import { updateJournalLine } from "./command/updateJournalLine.generated";
+import { verifySubledgerTransfers } from "./command/verifySubledgerTransfers.generated";
+import { verifyTrialBalance } from "./command/verifyTrialBalance.generated";
+import {
+  createAccountingPeriodType,
+  type CreateAccountingPeriodTypeParams,
+} from "./db/accountingPeriod";
+import {
+  createFinancialStatementType,
+  type CreateFinancialStatementTypeParams,
+} from "./db/financialStatement";
+import {
+  createFinancialStatementLineItemType,
+  type CreateFinancialStatementLineItemTypeParams,
+} from "./db/financialStatementLineItem";
+import { createFiscalYearType, type CreateFiscalYearTypeParams } from "./db/fiscalYear";
+import { createJournalEntryType, type CreateJournalEntryTypeParams } from "./db/journalEntry";
+import { createJournalLineType, type CreateJournalLineTypeParams } from "./db/journalLine";
+import { createPeriodCloseType, type CreatePeriodCloseTypeParams } from "./db/periodClose";
+import { createTrialBalanceType, type CreateTrialBalanceTypeParams } from "./db/trialBalance";
+import {
+  createTrialBalanceLineType,
+  type CreateTrialBalanceLineTypeParams,
+} from "./db/trialBalanceLine";
+import { getAccountingPeriod } from "./query/getAccountingPeriod.generated";
+import { getFinancialStatement } from "./query/getFinancialStatement.generated";
+import { getFiscalYear } from "./query/getFiscalYear.generated";
+import { getJournalEntry } from "./query/getJournalEntry.generated";
+import { getPeriodByDate } from "./query/getPeriodByDate.generated";
+import { getPeriodClose } from "./query/getPeriodClose.generated";
+import { getSubledgerTransferStatus } from "./query/getSubledgerTransferStatus.generated";
+import { getTrialBalance } from "./query/getTrialBalance.generated";
+import { listAccountingPeriods } from "./query/listAccountingPeriods.generated";
+import { listFinancialStatements } from "./query/listFinancialStatements.generated";
+import { listFiscalYears } from "./query/listFiscalYears.generated";
+import { listJournalEntries } from "./query/listJournalEntries.generated";
+import { listPeriodCloses } from "./query/listPeriodCloses.generated";
+import { listTrialBalances } from "./query/listTrialBalances.generated";
+
+type OrganizationModule = ReturnType<typeof defineOrganizationModule>;
+type OrganizationDB = OrganizationModule["db"];
+type CoaManagementModule = ReturnType<typeof defineCoaManagementModule>;
+type CoaManagementDB = CoaManagementModule["db"];
+type PrimitivesModule = ReturnType<typeof definePrimitivesModule>;
+type PrimitivesDB = PrimitivesModule["db"];
+type UserManagementModule = ReturnType<typeof defineUserManagementModule>;
+type UserManagementDB = UserManagementModule["db"];
+
+export interface DefineModuleParams<
+  FyF extends Record<string, TailorAnyDBField> = EmptyFields,
+  ApF extends Record<string, TailorAnyDBField> = EmptyFields,
+  JeF extends Record<string, TailorAnyDBField> = EmptyFields,
+  JlF extends Record<string, TailorAnyDBField> = EmptyFields,
+  PcF extends Record<string, TailorAnyDBField> = EmptyFields,
+  TbF extends Record<string, TailorAnyDBField> = EmptyFields,
+  TblF extends Record<string, TailorAnyDBField> = EmptyFields,
+  FsF extends Record<string, TailorAnyDBField> = EmptyFields,
+  FslF extends Record<string, TailorAnyDBField> = EmptyFields,
+> {
+  fiscalYear?: CreateFiscalYearTypeParams<FyF>;
+  accountingPeriod?: CreateAccountingPeriodTypeParams<ApF>;
+  journalEntry?: CreateJournalEntryTypeParams<JeF>;
+  journalLine?: CreateJournalLineTypeParams<JlF>;
+  periodClose?: CreatePeriodCloseTypeParams<PcF>;
+  trialBalance?: CreateTrialBalanceTypeParams<TbF>;
+  trialBalanceLine?: CreateTrialBalanceLineTypeParams<TblF>;
+  financialStatement?: CreateFinancialStatementTypeParams<FsF>;
+  financialStatementLineItem?: CreateFinancialStatementLineItemTypeParams<FslF>;
+  organization: {
+    db: {
+      company: OrganizationDB["company"];
+    };
+  };
+  coaManagement: {
+    db: {
+      account: CoaManagementDB["account"];
+      accountGroup: CoaManagementDB["accountGroup"];
+      chartOfAccounts: CoaManagementDB["chartOfAccounts"];
+    };
+  };
+  primitives: {
+    db: {
+      currency: PrimitivesDB["currency"];
+    };
+  };
+  userManagement: {
+    db: {
+      user: UserManagementDB["user"];
+    };
+  };
+}
+
+export const defineModule = <
+  const FyF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const ApF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const JeF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const JlF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const PcF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const TbF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const TblF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const FsF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const FslF extends Record<string, TailorAnyDBField> = EmptyFields,
+>(
+  params: DefineModuleParams<FyF, ApF, JeF, JlF, PcF, TbF, TblF, FsF, FslF>,
+) => {
+  const fiscalYearDb = createFiscalYearType({
+    ...params.fiscalYear,
+    companyType: params.organization.db.company,
+  });
+  const accountingPeriodDb = createAccountingPeriodType({
+    ...params.accountingPeriod,
+    companyType: params.organization.db.company,
+    fiscalYearType: fiscalYearDb,
+  });
+  const journalEntryDb = createJournalEntryType({
+    ...params.journalEntry,
+    companyType: params.organization.db.company,
+    accountingPeriodType: accountingPeriodDb,
+  });
+  const journalLineDb = createJournalLineType({
+    ...params.journalLine,
+    journalEntryType: journalEntryDb,
+    accountType: params.coaManagement.db.account,
+  });
+  const periodCloseDb = createPeriodCloseType({
+    ...params.periodClose,
+    accountingPeriodType: accountingPeriodDb,
+    initiatedByUserType: params.userManagement.db.user,
+    approvedByUserType: params.userManagement.db.user,
+  });
+  const trialBalanceDb = createTrialBalanceType({
+    ...params.trialBalance,
+    companyType: params.organization.db.company,
+    accountingPeriodType: accountingPeriodDb,
+    chartOfAccountsType: params.coaManagement.db.chartOfAccounts,
+  });
+  const trialBalanceLineDb = createTrialBalanceLineType({
+    ...params.trialBalanceLine,
+    trialBalanceType: trialBalanceDb,
+    accountType: params.coaManagement.db.account,
+    accountGroupType: params.coaManagement.db.accountGroup,
+  });
+  const financialStatementDb = createFinancialStatementType({
+    ...params.financialStatement,
+    companyType: params.organization.db.company,
+    chartOfAccountsType: params.coaManagement.db.chartOfAccounts,
+    trialBalanceType: trialBalanceDb,
+  });
+  const financialStatementLineItemDb = createFinancialStatementLineItemType({
+    ...params.financialStatementLineItem,
+    financialStatementType: financialStatementDb,
+    accountType: params.coaManagement.db.account,
+    accountGroupType: params.coaManagement.db.accountGroup,
+  });
+
+  return {
+    db: {
+      fiscalYear: fiscalYearDb,
+      accountingPeriod: accountingPeriodDb,
+      journalEntry: journalEntryDb,
+      journalLine: journalLineDb,
+      periodClose: periodCloseDb,
+      trialBalance: trialBalanceDb,
+      trialBalanceLine: trialBalanceLineDb,
+      financialStatement: financialStatementDb,
+      financialStatementLineItem: financialStatementLineItemDb,
+    },
+    commands: {
+      addJournalLine: addJournalLine(),
+      approveAndLockPeriod: approveAndLockPeriod(),
+      beginClose: beginClose(),
+      closePeriod: closePeriod(),
+      createAccountingPeriod: createAccountingPeriod(),
+      createFiscalYear: createFiscalYear(),
+      createJournalEntry: createJournalEntry(),
+      deleteAccountingPeriod: deleteAccountingPeriod(),
+      deleteFiscalYear: deleteFiscalYear(),
+      deleteJournalEntry: deleteJournalEntry(),
+      executeYearEndClose: executeYearEndClose(),
+      finalCloseAndLockPeriod: finalCloseAndLockPeriod(),
+      finalizeFinancialStatement: finalizeFinancialStatement(),
+      generateFinancialStatement: generateFinancialStatement(),
+      generatePreliminaryStatements: generatePreliminaryStatements(),
+      generateTrialBalance: generateTrialBalance(),
+      initiatePeriodClose: initiatePeriodClose(),
+      openForAdvanceEntry: openForAdvanceEntry(),
+      openPeriod: openPeriod(),
+      permanentlyClosePeriod: permanentlyClosePeriod(),
+      postAdjustingEntries: postAdjustingEntries(),
+      postJournalEntry: postJournalEntry(),
+      processInventoryHandoff: processInventoryHandoff(),
+      processManufacturingHandoff: processManufacturingHandoff(),
+      processPurchaseHandoff: processPurchaseHandoff(),
+      processSalesHandoff: processSalesHandoff(),
+      regenerateFinancialStatement: regenerateFinancialStatement(),
+      removeJournalLine: removeJournalLine(),
+      reopenPeriod: reopenPeriod(),
+      reverseJournalEntry: reverseJournalEntry(),
+      revertSoftLock: revertSoftLock(),
+      updateFiscalYear: updateFiscalYear(),
+      updateJournalEntry: updateJournalEntry(),
+      updateJournalLine: updateJournalLine(),
+      verifySubledgerTransfers: verifySubledgerTransfers(),
+      verifyTrialBalance: verifyTrialBalance(),
+    },
+    queries: {
+      getAccountingPeriod,
+      getFinancialStatement,
+      getFiscalYear,
+      getJournalEntry,
+      getPeriodByDate,
+      getPeriodClose,
+      getSubledgerTransferStatus,
+      getTrialBalance,
+      listAccountingPeriods,
+      listFinancialStatements,
+      listFiscalYears,
+      listJournalEntries,
+      listPeriodCloses,
+      listTrialBalances,
+    },
+  };
+};

package/src/modules/finance-ledger/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "finance-ledger",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "generate": "tailor-sdk generate",
+    "lint": "eslint --cache .",
+    "lint:fix": "eslint --cache --fix .",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@tailor-platform/erp-kit": "0.6.0",
+    "@tailor-platform/sdk": "1.25.4"
+  },
+  "devDependencies": {
+    "@eslint/js": "10.0.1",
+    "@tailor-platform/function-types": "0.8.2",
+    "@types/node": "24.12.0",
+    "@typescript-eslint/parser": "^8.57.0",
+    "eslint": "10.0.3",
+    "eslint-import-resolver-typescript": "4.4.4",
+    "eslint-plugin-import-x": "4.16.2",
+    "typescript": "5.9.3",
+    "typescript-eslint": "8.57.0"
+  }
+}

package/src/modules/finance-ledger/permissions.ts

@@ -0,0 +1,3 @@
+import { definePermissions } from "@tailor-platform/erp-kit/module";
+
+export const { permissions, own, all } = definePermissions("finance-ledger", [] as const);

package/src/modules/finance-ledger/query/getAccountingPeriod.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+import { run } from "./getAccountingPeriod";
+
+export const getAccountingPeriod = defineQuery(run);

package/src/modules/finance-ledger/query/getAccountingPeriod.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseAccountingPeriod } from "../testing/fixtures";
+import { run } from "./getAccountingPeriod";
+
+describe("getAccountingPeriod", () => {
+  it("returns accounting period when found by id", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(baseAccountingPeriod);
+
+    const result = await run(db, { id: baseAccountingPeriod.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.accountingPeriod).toEqual(baseAccountingPeriod);
+    }
+  });
+
+  it("returns null when not found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(undefined);
+
+    const result = await run(db, { id: "nonexistent" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.accountingPeriod).toBeNull();
+    }
+  });
+});

package/src/modules/finance-ledger/query/getAccountingPeriod.ts

@@ -0,0 +1,21 @@
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+import type { DB } from "../generated/kysely-tailordb";
+
+export interface GetAccountingPeriodInput {
+  id: string;
+}
+
+/**
+ * Function: getAccountingPeriod
+ *
+ * Retrieves a single accounting period by id.
+ */
+export async function run(db: ReadonlyDB<DB>, input: GetAccountingPeriodInput) {
+  const result = await db
+    .selectFrom("AccountingPeriod")
+    .selectAll()
+    .where("id", "=", input.id)
+    .executeTakeFirst();
+
+  return ok({ accountingPeriod: result ?? null });
+}

package/src/modules/finance-ledger/query/getFinancialStatement.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+import { run } from "./getFinancialStatement";
+
+export const getFinancialStatement = defineQuery(run);

package/src/modules/finance-ledger/query/getFinancialStatement.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseFinancialStatement, baseFinancialStatementLineItem } from "../testing/fixtures";
+import { run } from "./getFinancialStatement";
+
+describe("getFinancialStatement", () => {
+  it("returns financial statement with line items when found by id", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseFinancialStatement)
+      .mockReturnValueOnce([baseFinancialStatementLineItem]);
+
+    const result = await run(db, { id: baseFinancialStatement.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.financialStatement).toEqual(baseFinancialStatement);
+      expect(result.value.lineItems).toEqual([baseFinancialStatementLineItem]);
+    }
+  });
+
+  it("returns null with empty line items when not found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(undefined);
+
+    const result = await run(db, { id: "nonexistent" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.financialStatement).toBeNull();
+      expect(result.value.lineItems).toEqual([]);
+    }
+  });
+});

package/src/modules/finance-ledger/query/getFinancialStatement.ts

@@ -0,0 +1,29 @@
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+import type { DB } from "../generated/kysely-tailordb";
+
+export interface GetFinancialStatementInput {
+  id: string;
+}
+
+/**
+ * Function: getFinancialStatement
+ *
+ * Retrieves a single financial statement by id, along with its associated line items.
+ */
+export async function run(db: ReadonlyDB<DB>, input: GetFinancialStatementInput) {
+  const result = await db
+    .selectFrom("FinancialStatement")
+    .selectAll()
+    .where("id", "=", input.id)
+    .executeTakeFirst();
+
+  const lineItems = result
+    ? await db
+        .selectFrom("FinancialStatementLineItem")
+        .selectAll()
+        .where("financialStatementId", "=", input.id)
+        .execute()
+    : [];
+
+  return ok({ financialStatement: result ?? null, lineItems });
+}

package/src/modules/finance-ledger/query/getFiscalYear.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+import { run } from "./getFiscalYear";
+
+export const getFiscalYear = defineQuery(run);

package/src/modules/finance-ledger/query/getFiscalYear.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseFiscalYear } from "../testing/fixtures";
+import { run } from "./getFiscalYear";
+
+describe("getFiscalYear", () => {
+  it("returns fiscal year when found by id", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(baseFiscalYear);
+
+    const result = await run(db, { id: baseFiscalYear.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.fiscalYear).toEqual(baseFiscalYear);
+    }
+  });
+
+  it("returns null when not found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(undefined);
+
+    const result = await run(db, { id: "nonexistent" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.fiscalYear).toBeNull();
+    }
+  });
+});

package/src/modules/finance-ledger/query/getFiscalYear.ts

@@ -0,0 +1,21 @@
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+import type { DB } from "../generated/kysely-tailordb";
+
+export interface GetFiscalYearInput {
+  id: string;
+}
+
+/**
+ * Function: getFiscalYear
+ *
+ * Retrieves a single fiscal year by id.
+ */
+export async function run(db: ReadonlyDB<DB>, input: GetFiscalYearInput) {
+  const result = await db
+    .selectFrom("FiscalYear")
+    .selectAll()
+    .where("id", "=", input.id)
+    .executeTakeFirst();
+
+  return ok({ fiscalYear: result ?? null });
+}

package/src/modules/finance-ledger/query/getJournalEntry.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+import { run } from "./getJournalEntry";
+
+export const getJournalEntry = defineQuery(run);

package/src/modules/finance-ledger/query/getJournalEntry.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseJournalEntry, baseJournalLine, baseJournalLine2 } from "../testing/fixtures";
+import { run } from "./getJournalEntry";
+
+describe("getJournalEntry", () => {
+  it("returns journal entry with journal lines when found by id", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseJournalEntry)
+      .mockReturnValueOnce([baseJournalLine, baseJournalLine2]);
+
+    const result = await run(db, { id: baseJournalEntry.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.journalEntry).toEqual(baseJournalEntry);
+      expect(result.value.journalLines).toEqual([baseJournalLine, baseJournalLine2]);
+    }
+  });
+
+  it("returns null with empty journal lines when not found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(undefined);
+
+    const result = await run(db, { id: "nonexistent" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.journalEntry).toBeNull();
+      expect(result.value.journalLines).toEqual([]);
+    }
+  });
+});

package/src/modules/finance-ledger/query/getJournalEntry.ts

@@ -0,0 +1,29 @@
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+import type { DB } from "../generated/kysely-tailordb";
+
+export interface GetJournalEntryInput {
+  id: string;
+}
+
+/**
+ * Function: getJournalEntry
+ *
+ * Retrieves a single journal entry by id, along with its associated journal lines.
+ */
+export async function run(db: ReadonlyDB<DB>, input: GetJournalEntryInput) {
+  const result = await db
+    .selectFrom("JournalEntry")
+    .selectAll()
+    .where("id", "=", input.id)
+    .executeTakeFirst();
+
+  const journalLines = result
+    ? await db
+        .selectFrom("JournalLine")
+        .selectAll()
+        .where("journalEntryId", "=", input.id)
+        .execute()
+    : [];
+
+  return ok({ journalEntry: result ?? null, journalLines });
+}

package/src/modules/finance-ledger/query/getPeriodByDate.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+import { run } from "./getPeriodByDate";
+
+export const getPeriodByDate = defineQuery(run);

package/src/modules/finance-ledger/query/getPeriodByDate.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseAccountingPeriod } from "../testing/fixtures";
+import { run } from "./getPeriodByDate";
+
+describe("getPeriodByDate", () => {
+  it("returns period when date falls within range", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(baseAccountingPeriod);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      date: new Date("2024-01-15"),
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.accountingPeriod).toEqual(baseAccountingPeriod);
+    }
+  });
+
+  it("returns null when no period covers the date", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(undefined);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      date: new Date("2025-06-15"),
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.accountingPeriod).toBeNull();
+    }
+  });
+
+  it("only returns OPERATING periods (not ADJUSTMENT)", async () => {
+    const { db, spies } = createMockDb<DB>();
+    // When no OPERATING period matches (e.g., only ADJUSTMENT exists), returns undefined
+    spies.select.mockReturnValue(undefined);
+
+    const result = await run(db, {
+      companyId: "company-1",
+      date: new Date("2024-01-15"),
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.accountingPeriod).toBeNull();
+    }
+  });
+});

package/src/modules/finance-ledger/query/getPeriodByDate.ts

@@ -0,0 +1,27 @@
+import { ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+import type { DB } from "../generated/kysely-tailordb";
+
+export interface GetPeriodByDateInput {
+  companyId: string;
+  date: Date;
+}
+
+/**
+ * Function: getPeriodByDate
+ *
+ * Finds the operating period containing a given date for a specific company.
+ * Searches where startDate <= date <= endDate and periodType = OPERATING.
+ * Only OPERATING periods returned. Returns null if no operating period covers the date.
+ */
+export async function run(db: ReadonlyDB<DB>, input: GetPeriodByDateInput) {
+  const period = await db
+    .selectFrom("AccountingPeriod")
+    .selectAll()
+    .where("companyId", "=", input.companyId)
+    .where("periodType", "=", "OPERATING")
+    .where("startDate", "<=", input.date)
+    .where("endDate", ">=", input.date)
+    .executeTakeFirst();
+
+  return ok({ accountingPeriod: period ?? null });
+}

package/src/modules/finance-ledger/query/getPeriodClose.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { defineQuery } from "@tailor-platform/erp-kit/module";
+import { run } from "./getPeriodClose";
+
+export const getPeriodClose = defineQuery(run);