@dloizides/invoice-core 0.1.0 → 0.2.0

package/dist/index.mjs

@@ -5,6 +5,9 @@ var StorageExistsError = class extends Error {
     this.name = "StorageExistsError";
   }
 };
+function isStorageExistsError(error) {
+  return typeof error === "object" && error !== null && error.name === "StorageExistsError";
+}
 
 // src/types.ts
 var InvoiceError = class extends Error {
@@ -21,6 +24,11 @@ var FORMAT_VERSION = 1;
 var NUMBER_YEAR = /(\d{4})-\d+$/;
 var LEGACY_YEAR = /^\d{4}$/;
 var LEGACY_FILE = /^(\d{4}-\d+)\.(json|pdf)$/;
+var OS_FILES = /* @__PURE__ */ new Set(["desktop.ini", "thumbs.db", ".ds_store"]);
+var NUMBER_SHAPE = /^(CN-)?\d{4}-\d+$/;
+function isOsFile(name) {
+  return OS_FILES.has(name.toLowerCase());
+}
 function toJson(value2) {
   return JSON.stringify(value2, null, 2);
 }
@@ -56,7 +64,7 @@ async function ensureFormat(storage) {
   const text = await storage.readText(FORMAT_PATH);
   if (text === null) {
     await storage.writeNew(FORMAT_PATH, toJson({ version: FORMAT_VERSION })).catch((error) => {
-      if (!(error instanceof StorageExistsError)) {
+      if (!isStorageExistsError(error)) {
         throw error;
       }
     });
@@ -99,6 +107,85 @@ async function migrateLegacyFolder(storage) {
   return result;
 }
 
+// src/FolderConflictKind.ts
+var FolderConflictKind = /* @__PURE__ */ ((FolderConflictKind2) => {
+  FolderConflictKind2["SyncCopy"] = "sync copy";
+  FolderConflictKind2["DuplicateNumber"] = "duplicate number";
+  FolderConflictKind2["UnreadableRecord"] = "unreadable record";
+  return FolderConflictKind2;
+})(FolderConflictKind || {});
+
+// src/conflicts.ts
+var RECORD_FILE = "invoice.json";
+var STATUS_FILE = "status.json";
+var LEGACY_FILE2 = /^(\d{4}-\d+)\.(json|pdf)$/;
+function seriesKey(number) {
+  const separator = number.lastIndexOf("-");
+  return `${number.slice(0, separator)}-${Number(number.slice(separator + 1))}`;
+}
+async function recordConflict(storage, dir, number) {
+  const path = `${dir}/${RECORD_FILE}`;
+  const text = await storage.readText(path);
+  if (text === null) {
+    return [];
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return [{ kind: "unreadable record" /* UnreadableRecord */, path }];
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return [{ kind: "unreadable record" /* UnreadableRecord */, path }];
+  }
+  return parsed.number === number ? [] : [{ kind: "duplicate number" /* DuplicateNumber */, path }];
+}
+async function numberFolderConflicts(storage, dir, number) {
+  const allowed = /* @__PURE__ */ new Set([RECORD_FILE, STATUS_FILE, `${number}.pdf`]);
+  const copies = (await storage.list(dir)).filter((name) => !allowed.has(name) && !isOsFile(name)).map((name) => ({ kind: "sync copy" /* SyncCopy */, path: `${dir}/${name}` }));
+  return [...copies, ...await recordConflict(storage, dir, number)];
+}
+async function currentLayoutConflicts(storage, year) {
+  const conflicts = [];
+  const numbers = /* @__PURE__ */ new Set();
+  const keys = /* @__PURE__ */ new Set();
+  const yearDir = `invoices/${year}`;
+  for (const name of (await storage.list(yearDir)).filter((entry) => !isOsFile(entry))) {
+    const path = `${yearDir}/${name}`;
+    if (!NUMBER_SHAPE.test(name) || numberYear(name) !== year) {
+      conflicts.push({ kind: "sync copy" /* SyncCopy */, path });
+    } else if (keys.has(seriesKey(name))) {
+      conflicts.push({ kind: "duplicate number" /* DuplicateNumber */, path });
+    } else {
+      keys.add(seriesKey(name));
+      numbers.add(name);
+      conflicts.push(...await numberFolderConflicts(storage, path, name));
+    }
+  }
+  return { conflicts, numbers };
+}
+async function legacyLayoutConflicts(storage, year, numbers) {
+  const names = (await storage.list(year)).filter((name) => !isOsFile(name));
+  return names.flatMap((name) => {
+    const number = LEGACY_FILE2.exec(name)?.[1];
+    const path = `${year}/${name}`;
+    if (number === void 0 || numberYear(number) !== year) {
+      return [{ kind: "sync copy" /* SyncCopy */, path }];
+    }
+    return numbers.has(number) ? [{ kind: "duplicate number" /* DuplicateNumber */, path }] : [];
+  });
+}
+async function findFolderConflicts(storage, year) {
+  const { conflicts, numbers } = await currentLayoutConflicts(storage, year);
+  return [...conflicts, ...await legacyLayoutConflicts(storage, year, numbers)];
+}
+async function assertNoConflicts(storage, year) {
+  const conflicts = await findFolderConflicts(storage, year);
+  if (conflicts.length > 0) {
+    throw new InvoiceError(conflicts.map(({ kind, path }) => ({ path: "folder", message: `${kind}: ${path}` })));
+  }
+}
+
 // src/InvoiceKind.ts
 var InvoiceKind = /* @__PURE__ */ ((InvoiceKind2) => {
   InvoiceKind2["Invoice"] = "invoice";
@@ -268,7 +355,7 @@ async function claimInvoice(storage, record) {
   try {
     await storage.writeNew(path, toJson(record));
   } catch (error) {
-    const message = error instanceof StorageExistsError ? `${record.number} is already issued` : `could not save ${record.number}: ${error.message}`;
+    const message = isStorageExistsError(error) ? `${record.number} is already issued` : `could not save ${record.number}: ${error.message}`;
     throw new InvoiceError([{ path: "number", message }]);
   }
   return path;
@@ -654,7 +741,6 @@ async function renderInvoicePdf(storage, input) {
 }
 
 // src/issue.ts
-var NUMBER_SHAPE = /^(CN-)?\d{4}-\d+$/;
 var NUMBER_LOCK = "invoice-number";
 function rendererFor(storage, options) {
   return options.render ?? ((input) => renderInvoicePdf(storage, input));
@@ -676,6 +762,7 @@ async function issueInvoice(storage, request, options = {}) {
   await ensureFormat(storage);
   const render = rendererFor(storage, options);
   return storage.withLock(NUMBER_LOCK, async () => {
+    await assertNoConflicts(storage, final.date.slice(0, 4));
     const number = await nextNumber(storage, final.date.slice(0, 4));
     const lines2 = resolveLines(final, parties.client);
     const pdf = await render({ request: final, number, parties, lines: lines2 });
@@ -762,6 +849,7 @@ async function issueCreditNote(storage, input, options = {}) {
   checkTarget(invoice, input);
   const render = rendererFor(storage, options);
   return storage.withLock(NUMBER_LOCK, async () => {
+    await assertNoConflicts(storage, input.date.slice(0, 4));
     const remaining = invoice.totals.netCents - await creditedSoFar(storage, invoice, input.date);
     const cents = creditCents(input, remaining);
     const number = await nextNumber(storage, input.date.slice(0, 4), "credit-note" /* CreditNote */);
@@ -826,6 +914,15 @@ async function exportQuarterCsv(storage, year, quarter) {
   return `${BOM}${[HEADER.join(","), ...records.map(toRow)].join(NEWLINE)}${NEWLINE}`;
 }
 
+// src/FolderOpenState.ts
+var FolderOpenState = /* @__PURE__ */ ((FolderOpenState2) => {
+  FolderOpenState2["New"] = "new";
+  FolderOpenState2["Existing"] = "existing";
+  FolderOpenState2["Legacy"] = "legacy";
+  FolderOpenState2["Foreign"] = "foreign";
+  return FolderOpenState2;
+})(FolderOpenState || {});
+
 // src/memoryStorage.ts
 function toBytes2(data) {
   return typeof data === "string" ? new TextEncoder().encode(data) : data;
@@ -869,6 +966,69 @@ function createMemoryStorage(initial = {}) {
   };
 }
 
+// src/openFolder.ts
+var DATA_ENTRIES = /* @__PURE__ */ new Set(["company.json", "clients", "invoices", "rules", "layouts", "schedules"]);
+var LEGACY_YEAR2 = /^\d{4}$/;
+async function openDataFolder(storage) {
+  const names = (await storage.list("")).filter((name) => !isOsFile(name));
+  if (names.includes(FORMAT_PATH)) {
+    await ensureFormat(storage);
+    return "existing" /* Existing */;
+  }
+  if (names.length === 0) {
+    await ensureFormat(storage);
+    return "new" /* New */;
+  }
+  return names.some((name) => DATA_ENTRIES.has(name) || LEGACY_YEAR2.test(name)) ? "legacy" /* Legacy */ : "foreign" /* Foreign */;
+}
+
+// src/PaymentState.ts
+var PaymentState = /* @__PURE__ */ ((PaymentState2) => {
+  PaymentState2["Paid"] = "paid";
+  PaymentState2["Unpaid"] = "unpaid";
+  PaymentState2["Overdue"] = "overdue";
+  return PaymentState2;
+})(PaymentState || {});
+
+// src/paymentStatus.ts
+var STATUS_LOCK = "invoice-status";
+function statusPath(number) {
+  return `${invoiceDir(number)}/status.json`;
+}
+async function readPaymentStatus(storage, number) {
+  const path = statusPath(number);
+  if (await storage.readText(path) === null) {
+    return { paidOn: null };
+  }
+  const { paidOn } = await readJsonFile(storage, path, "status");
+  return { paidOn: typeof paidOn === "string" ? paidOn : null };
+}
+async function markPaid(storage, number, paidOn) {
+  if (!isRealDate(paidOn)) {
+    throw new InvoiceError([{ path: "paidOn", message: "must be a real date as YYYY-MM-DD" }]);
+  }
+  const record = await readInvoice(storage, number);
+  if (record.kind !== "invoice" /* Invoice */) {
+    throw new InvoiceError([{ path: "number", message: `${number} is a credit note; only an invoice can be paid` }]);
+  }
+  if (paidOn < record.request.date) {
+    throw new InvoiceError([{ path: "paidOn", message: `must not be before the invoice date ${record.request.date}` }]);
+  }
+  const payment2 = { paidOn };
+  await storage.withLock(STATUS_LOCK, () => storage.replace(statusPath(number), toJson(payment2)));
+}
+async function markUnpaid(storage, number) {
+  await storage.withLock(STATUS_LOCK, () => storage.remove(statusPath(number)));
+}
+function paymentStateOf(record, status, today) {
+  if (status.paidOn !== null) {
+    return "paid" /* Paid */;
+  }
+  const terms = record.client.paymentTermsDays;
+  const overdue = typeof terms === "number" && today > addDays(record.request.date, terms);
+  return overdue ? "overdue" /* Overdue */ : "unpaid" /* Unpaid */;
+}
+
 // src/schedule.ts
 var MONTHS_IN_YEAR = 12;
 var YEAR3 = /^\d{4}$/;
@@ -899,7 +1059,7 @@ async function prepareYearSchedule(storage, request) {
   try {
     await storage.writeNew(schedulePath(schedule.id), toJson(schedule));
   } catch (error) {
-    if (error instanceof StorageExistsError) {
+    if (isStorageExistsError(error)) {
       throw new InvoiceError([{ path: "schedule", message: `${schedule.id} is already prepared` }]);
     }
     throw error;
@@ -977,6 +1137,6 @@ async function issueDueMonths(storage, id, options) {
   return storage.withLock(lockName(id), async () => issueRun(storage, await reconcile(storage, await readSchedule(storage, id), options.today), options));
 }
 
-export { BUILT_IN_LAYOUTS, BUILT_IN_RULES, DEFAULT_LAYOUT, InvoiceError, InvoiceKind, LayoutAlign, NUMBER_LOCK, StorageExistsError, addDays, centsToAmount, checkRequest, claimInvoice, computeTotals, createMemoryStorage, displayDate, editScheduleMonth, ensureFormat, expandDescription, exportQuarterCsv, formatCents, invoiceDir, isBlank, isRealDate, issueCreditNote, issueDueMonths, issueInvoice, listIssued, loadLogo, loadParties, migrateLegacyFolder, missingForFinal, nextNumber, parseLayout, pdfPath, periodTexts, prepareYearSchedule, readInvoice, readSchedule, recordPath, renderDraftPdf, renderInvoicePdf, reprintInvoice, resolveLayout, resolveLines, selectLayoutName, toCents, validateLines, validateRequest, vatCents };
+export { BUILT_IN_LAYOUTS, BUILT_IN_RULES, DEFAULT_LAYOUT, FolderConflictKind, FolderOpenState, InvoiceError, InvoiceKind, LayoutAlign, NUMBER_LOCK, PaymentState, StorageExistsError, addDays, assertNoConflicts, centsToAmount, checkRequest, claimInvoice, computeTotals, createMemoryStorage, displayDate, editScheduleMonth, ensureFormat, expandDescription, exportQuarterCsv, findFolderConflicts, formatCents, invoiceDir, isBlank, isRealDate, isStorageExistsError, issueCreditNote, issueDueMonths, issueInvoice, listIssued, loadLogo, loadParties, markPaid, markUnpaid, migrateLegacyFolder, missingForFinal, nextNumber, openDataFolder, parseLayout, paymentStateOf, pdfPath, periodTexts, prepareYearSchedule, readInvoice, readPaymentStatus, readSchedule, recordPath, renderDraftPdf, renderInvoicePdf, reprintInvoice, resolveLayout, resolveLines, selectLayoutName, toCents, validateLines, validateRequest, vatCents };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map