@tailor-platform/erp-kit 0.7.0 → 0.8.0

package/src/modules/accounting/lib/_db_deps.ts

@@ -0,0 +1,70 @@
+// Stub types for cross-module dependencies — used only for codegen.
+// At runtime, actual types are injected via defineModule() params.
+import {
+  db,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+
+export const company = db
+  .type("Company", {
+    status: db.string({ optional: true }),
+  })
+  .permission(unsafeAllowAllTypePermission)
+  .gqlPermission(unsafeAllowAllGqlPermission);
+
+export const account = db
+  .type("Account", {
+    code: db.string({ optional: true }),
+    name: db.string({ optional: true }),
+    classification: db.string({ optional: true }),
+    status: db.string({ optional: true }),
+    chartOfAccountsId: db.uuid({ optional: true }),
+  })
+  .permission(unsafeAllowAllTypePermission)
+  .gqlPermission(unsafeAllowAllGqlPermission);
+
+export const chartOfAccounts = db
+  .type(["ChartOfAccounts", "ChartsOfAccounts"], {
+    companyId: db.uuid({ optional: true }),
+    status: db.string({ optional: true }),
+  })
+  .permission(unsafeAllowAllTypePermission)
+  .gqlPermission(unsafeAllowAllGqlPermission);
+
+export const user = db
+  .type("User", {
+    status: db.string({ optional: true }),
+  })
+  .permission(unsafeAllowAllTypePermission)
+  .gqlPermission(unsafeAllowAllGqlPermission);
+
+export const department = db
+  .type("Department", {
+    name: db.string({ optional: true }),
+  })
+  .permission(unsafeAllowAllTypePermission)
+  .gqlPermission(unsafeAllowAllGqlPermission);
+
+export const accountingPeriod = db
+  .type("AccountingPeriod", {
+    companyId: db.uuid({ optional: true }),
+    fiscalYearId: db.uuid({ optional: true }),
+    status: db.string({ optional: true }),
+  })
+  .permission(unsafeAllowAllTypePermission)
+  .gqlPermission(unsafeAllowAllGqlPermission);
+
+export const fiscalYear = db
+  .type("FiscalYear", {
+    companyId: db.uuid({ optional: true }),
+  })
+  .permission(unsafeAllowAllTypePermission)
+  .gqlPermission(unsafeAllowAllGqlPermission);
+
+export const purchaseOrder = db
+  .type("PurchaseOrder", {
+    status: db.string({ optional: true }),
+  })
+  .permission(unsafeAllowAllTypePermission)
+  .gqlPermission(unsafeAllowAllGqlPermission);

package/src/modules/accounting/lib/actualAmounts.ts

@@ -0,0 +1,93 @@
+import type { DB, Transaction } from "../generated/kysely-tailordb";
+import type { ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+type QueryableDB = ReadonlyDB<DB> | Transaction;
+
+type ActualAmountRow = Record<string, unknown>;
+
+interface CrossModuleJournalLineQuery {
+  innerJoin(table: string, left: string, right: string): CrossModuleJournalLineQuery;
+  selectAll(table: string): CrossModuleJournalLineQuery;
+  where(column: string, operator: string, value: string): CrossModuleJournalLineQuery;
+  execute(): Promise<unknown>;
+}
+
+interface ActualAmountParams {
+  accountingPeriodId: string;
+  costObjectType: string;
+  costObjectId: string;
+}
+
+interface SumActualAmountParams extends ActualAmountParams {
+  costElementId: string;
+}
+
+function toNumber(value: unknown): number | null {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+
+function getRowAmount(row: ActualAmountRow): number {
+  const explicitAmount =
+    toNumber(row.amount) ??
+    toNumber(row.functionalAmount) ??
+    toNumber(row.actualAmount) ??
+    toNumber(row.netAmount);
+  if (explicitAmount !== null) {
+    return explicitAmount;
+  }
+
+  const debit = toNumber(row.functionalDebitAmount) ?? toNumber(row.debitAmount) ?? 0;
+  const credit = toNumber(row.functionalCreditAmount) ?? toNumber(row.creditAmount) ?? 0;
+
+  if (debit !== 0 || credit !== 0) {
+    return debit !== 0 ? debit : credit;
+  }
+
+  return 0;
+}
+
+async function listActualAmountRows(db: QueryableDB, params: ActualAmountParams) {
+  const query = db.selectFrom("JournalLine" as never) as unknown as CrossModuleJournalLineQuery;
+  const rows = await query
+    .innerJoin("JournalEntry", "JournalEntry.id", "JournalLine.journalEntryId")
+    .selectAll("JournalLine")
+    .where("JournalEntry.accountingPeriodId", "=", params.accountingPeriodId)
+    .where("JournalEntry.status", "=", "POSTED")
+    .where("JournalLine.costObjectType", "=", params.costObjectType)
+    .where("JournalLine.costObjectId", "=", params.costObjectId)
+    .execute();
+
+  return rows as ActualAmountRow[];
+}
+
+export async function listPostedActualAmountsByCostElement(
+  db: QueryableDB,
+  params: ActualAmountParams,
+) {
+  const rows = await listActualAmountRows(db, params);
+  const totals = new Map<string, number>();
+
+  for (const row of rows) {
+    const costElementId = typeof row.costElementId === "string" ? row.costElementId : null;
+    if (!costElementId) {
+      continue;
+    }
+
+    totals.set(costElementId, (totals.get(costElementId) ?? 0) + getRowAmount(row));
+  }
+
+  return totals;
+}
+
+export async function sumPostedActualAmount(db: QueryableDB, params: SumActualAmountParams) {
+  const rows = await listActualAmountRows(db, params);
+
+  return rows.reduce((sum, row) => {
+    const costElementId = typeof row.costElementId === "string" ? row.costElementId : null;
+    if (costElementId !== params.costElementId) {
+      return sum;
+    }
+
+    return sum + getRowAmount(row);
+  }, 0);
+}

package/src/modules/accounting/lib/allocationPosting.ts

@@ -0,0 +1,152 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+
+interface AllocationCycleLike {
+  id: string;
+  companyId: string;
+  accountingPeriodId: string;
+  allocationType: string;
+}
+
+interface AllocationResultLike {
+  id: string;
+  senderCostCenterId: string;
+  receiverType: string;
+  receiverId: string;
+  allocatedAmount: number;
+  costElementId: string;
+}
+
+interface JournalEntryLike {
+  id: string;
+  referenceNumber: string;
+  sourceDocumentReference: string | null;
+}
+
+const JOURNAL_TYPE = "MISCELLANEOUS";
+
+function buildPostingReferenceNumber(cycleId: string, resultId: string) {
+  return `ALLOC-${cycleId}-${resultId}`;
+}
+
+function buildReversalReferenceNumber(referenceNumber: string) {
+  return `REV-${referenceNumber}`;
+}
+
+function buildPostingSourceDocumentReference(cycleId: string) {
+  return `AllocationCycle:${cycleId}`;
+}
+
+function buildReversalSourceDocumentReference(cycleId: string) {
+  return `AllocationCycleReversal:${cycleId}`;
+}
+
+function buildPostingDescription(
+  cycle: AllocationCycleLike,
+  result: AllocationResultLike,
+  costElementType: string | null,
+) {
+  const elementRole = cycle.allocationType === "ASSESSMENT" ? "secondary" : "primary";
+
+  return [
+    `${cycle.allocationType} allocation posting`,
+    `sender=${result.senderCostCenterId}`,
+    `receiver=${result.receiverType}:${result.receiverId}`,
+    `costElement=${result.costElementId}`,
+    `role=${costElementType ?? elementRole}`,
+    `amount=${result.allocatedAmount}`,
+  ].join(" | ");
+}
+
+export async function createAllocationPostingEntries(
+  db: Transaction,
+  cycle: AllocationCycleLike,
+  allocationResults: AllocationResultLike[],
+) {
+  const now = new Date();
+  const createdEntries = [];
+
+  for (const result of allocationResults) {
+    const costElement = await db
+      .selectFrom("CostElement")
+      .selectAll()
+      .where("id", "=", result.costElementId)
+      .executeTakeFirst();
+
+    const costElementType = costElement?.type ?? null;
+
+    const journalEntry = await db
+      .insertInto("JournalEntry" as never)
+      .values({
+        companyId: cycle.companyId,
+        accountingPeriodId: cycle.accountingPeriodId,
+        entryDate: now,
+        journalType: JOURNAL_TYPE,
+        referenceNumber: buildPostingReferenceNumber(cycle.id, result.id),
+        status: "POSTED",
+        description: buildPostingDescription(cycle, result, costElementType),
+        sourceDocumentReference: buildPostingSourceDocumentReference(cycle.id),
+        adjustingEntryType: null,
+        reversalOfId: null,
+        postedAt: now,
+        createdAt: now,
+        updatedAt: null,
+      } as never)
+      .returningAll()
+      .executeTakeFirst();
+
+    createdEntries.push(journalEntry);
+  }
+
+  return createdEntries;
+}
+
+export async function createAllocationReversalEntries(db: Transaction, cycle: AllocationCycleLike) {
+  const originalEntries = (await db
+    .selectFrom("JournalEntry" as never)
+    .selectAll()
+    .where(
+      "sourceDocumentReference" as never,
+      "=",
+      buildPostingSourceDocumentReference(cycle.id) as never,
+    )
+    .where("status" as never, "=", "POSTED" as never)
+    .execute()) as JournalEntryLike[];
+
+  const now = new Date();
+  const reversalEntries = [];
+
+  for (const entry of originalEntries) {
+    const reversalEntry = await db
+      .insertInto("JournalEntry" as never)
+      .values({
+        companyId: cycle.companyId,
+        accountingPeriodId: cycle.accountingPeriodId,
+        entryDate: now,
+        journalType: JOURNAL_TYPE,
+        referenceNumber: buildReversalReferenceNumber(entry.referenceNumber),
+        status: "POSTED",
+        description: `Reversal of ${entry.referenceNumber}`,
+        sourceDocumentReference: buildReversalSourceDocumentReference(cycle.id),
+        adjustingEntryType: null,
+        reversalOfId: entry.id,
+        postedAt: now,
+        createdAt: now,
+        updatedAt: null,
+      } as never)
+      .returningAll()
+      .executeTakeFirst();
+
+    await db
+      .updateTable("JournalEntry" as never)
+      .set({
+        status: "REVERSED",
+        updatedAt: now,
+      } as never)
+      .where("id" as never, "=", entry.id as never)
+      .executeTakeFirst();
+
+    reversalEntries.push(reversalEntry);
+  }
+
+  return reversalEntries;
+}