@tailor-platform/erp-kit 0.4.1 → 0.5.1

package/src/modules/sales/lib/types.ts

@@ -0,0 +1,105 @@
+import type { DB } from "../generated/kysely-tailordb";
+import type {
+  InferSchema,
+  Selectable,
+  Insertable,
+  Updateable,
+} from "@tailor-platform/erp-kit/module";
+
+export type Schema = InferSchema<DB>;
+
+export type Channel<T extends { Channel: object }> = Selectable<T["Channel"]>;
+export type ChannelCreate<T extends { Channel: object }> = Insertable<T["Channel"]>;
+export type ChannelUpdate<T extends { Channel: object }> = Updateable<T["Channel"]>;
+
+export type Listing<T extends { Listing: object }> = Selectable<T["Listing"]>;
+export type ListingCreate<T extends { Listing: object }> = Insertable<T["Listing"]>;
+export type ListingUpdate<T extends { Listing: object }> = Updateable<T["Listing"]>;
+
+export type SalesPaymentTerm<T extends { SalesPaymentTerm: object }> = Selectable<
+  T["SalesPaymentTerm"]
+>;
+export type SalesPaymentTermCreate<T extends { SalesPaymentTerm: object }> = Insertable<
+  T["SalesPaymentTerm"]
+>;
+export type SalesPaymentTermUpdate<T extends { SalesPaymentTerm: object }> = Updateable<
+  T["SalesPaymentTerm"]
+>;
+
+export type SalesPriceList<T extends { SalesPriceList: object }> = Selectable<T["SalesPriceList"]>;
+export type SalesPriceListCreate<T extends { SalesPriceList: object }> = Insertable<
+  T["SalesPriceList"]
+>;
+export type SalesPriceListUpdate<T extends { SalesPriceList: object }> = Updateable<
+  T["SalesPriceList"]
+>;
+
+export type SalesPriceRule<T extends { SalesPriceRule: object }> = Selectable<T["SalesPriceRule"]>;
+export type SalesPriceRuleCreate<T extends { SalesPriceRule: object }> = Insertable<
+  T["SalesPriceRule"]
+>;
+export type SalesPriceRuleUpdate<T extends { SalesPriceRule: object }> = Updateable<
+  T["SalesPriceRule"]
+>;
+
+export type SalesOrder<T extends { SalesOrder: object }> = Selectable<T["SalesOrder"]>;
+export type SalesOrderCreate<T extends { SalesOrder: object }> = Insertable<T["SalesOrder"]>;
+export type SalesOrderUpdate<T extends { SalesOrder: object }> = Updateable<T["SalesOrder"]>;
+
+export type SalesOrderLine<T extends { SalesOrderLine: object }> = Selectable<T["SalesOrderLine"]>;
+export type SalesOrderLineCreate<T extends { SalesOrderLine: object }> = Insertable<
+  T["SalesOrderLine"]
+>;
+export type SalesOrderLineUpdate<T extends { SalesOrderLine: object }> = Updateable<
+  T["SalesOrderLine"]
+>;
+
+export type Shipment<T extends { Shipment: object }> = Selectable<T["Shipment"]>;
+export type ShipmentCreate<T extends { Shipment: object }> = Insertable<T["Shipment"]>;
+export type ShipmentUpdate<T extends { Shipment: object }> = Updateable<T["Shipment"]>;
+
+export type ShipmentLine<T extends { ShipmentLine: object }> = Selectable<T["ShipmentLine"]>;
+export type ShipmentLineCreate<T extends { ShipmentLine: object }> = Insertable<T["ShipmentLine"]>;
+export type ShipmentLineUpdate<T extends { ShipmentLine: object }> = Updateable<T["ShipmentLine"]>;
+
+export type SalesInvoice<T extends { SalesInvoice: object }> = Selectable<T["SalesInvoice"]>;
+export type SalesInvoiceCreate<T extends { SalesInvoice: object }> = Insertable<T["SalesInvoice"]>;
+export type SalesInvoiceUpdate<T extends { SalesInvoice: object }> = Updateable<T["SalesInvoice"]>;
+
+export type SalesInvoiceLine<T extends { SalesInvoiceLine: object }> = Selectable<
+  T["SalesInvoiceLine"]
+>;
+export type SalesInvoiceLineCreate<T extends { SalesInvoiceLine: object }> = Insertable<
+  T["SalesInvoiceLine"]
+>;
+export type SalesInvoiceLineUpdate<T extends { SalesInvoiceLine: object }> = Updateable<
+  T["SalesInvoiceLine"]
+>;
+
+export type SalesCreditNote<T extends { SalesCreditNote: object }> = Selectable<
+  T["SalesCreditNote"]
+>;
+export type SalesCreditNoteCreate<T extends { SalesCreditNote: object }> = Insertable<
+  T["SalesCreditNote"]
+>;
+export type SalesCreditNoteUpdate<T extends { SalesCreditNote: object }> = Updateable<
+  T["SalesCreditNote"]
+>;
+
+export type SalesCreditNoteLine<T extends { SalesCreditNoteLine: object }> = Selectable<
+  T["SalesCreditNoteLine"]
+>;
+export type SalesCreditNoteLineCreate<T extends { SalesCreditNoteLine: object }> = Insertable<
+  T["SalesCreditNoteLine"]
+>;
+export type SalesCreditNoteLineUpdate<T extends { SalesCreditNoteLine: object }> = Updateable<
+  T["SalesCreditNoteLine"]
+>;
+
+export type ChannelOrder<T extends { ChannelOrder: object }> = Selectable<T["ChannelOrder"]>;
+export type ChannelOrderCreate<T extends { ChannelOrder: object }> = Insertable<T["ChannelOrder"]>;
+export type ChannelOrderUpdate<T extends { ChannelOrder: object }> = Updateable<T["ChannelOrder"]>;
+
+export type SyncJob<T extends { SyncJob: object }> = Selectable<T["SyncJob"]>;
+export type SyncJobCreate<T extends { SyncJob: object }> = Insertable<T["SyncJob"]>;
+export type SyncJobUpdate<T extends { SyncJob: object }> = Updateable<T["SyncJob"]>;

package/src/modules/sales/module.ts

@@ -0,0 +1,418 @@
+import type { TailorAnyDBField } from "@tailor-platform/sdk";
+import type { defineModule as defineBusinessPartnerModule } from "../business-partner";
+import type { defineModule as defineItemManagementModule } from "../item-management";
+import type { defineModule as defineOrganizationModule } from "../organization";
+import type { defineModule as definePrimitivesModule } from "../primitives";
+import { activateChannel } from "./command/activateChannel.generated";
+import { activateListing } from "./command/activateListing.generated";
+import { activateSalesPaymentTerm } from "./command/activateSalesPaymentTerm.generated";
+import { activateSalesPriceList } from "./command/activateSalesPriceList.generated";
+import { activateSalesPriceRule } from "./command/activateSalesPriceRule.generated";
+import { cancelChannelOrder } from "./command/cancelChannelOrder.generated";
+import { cancelSalesInvoice } from "./command/cancelSalesInvoice.generated";
+import { cancelSalesOrder } from "./command/cancelSalesOrder.generated";
+import { cancelSyncJob } from "./command/cancelSyncJob.generated";
+import { closeSalesOrder } from "./command/closeSalesOrder.generated";
+import { confirmSalesOrder } from "./command/confirmSalesOrder.generated";
+import { convertChannelOrder } from "./command/convertChannelOrder.generated";
+import { createChannel } from "./command/createChannel.generated";
+import { createListing } from "./command/createListing.generated";
+import { createSalesCreditNote } from "./command/createSalesCreditNote.generated";
+import { createSalesInvoice } from "./command/createSalesInvoice.generated";
+import { createSalesOrder } from "./command/createSalesOrder.generated";
+import { createSalesPaymentTerm } from "./command/createSalesPaymentTerm.generated";
+import { createSalesPriceList } from "./command/createSalesPriceList.generated";
+import { createSalesPriceRule } from "./command/createSalesPriceRule.generated";
+import { createShipment } from "./command/createShipment.generated";
+import { deactivateChannel } from "./command/deactivateChannel.generated";
+import { deactivateSalesPaymentTerm } from "./command/deactivateSalesPaymentTerm.generated";
+import { deactivateSalesPriceList } from "./command/deactivateSalesPriceList.generated";
+import { deactivateSalesPriceRule } from "./command/deactivateSalesPriceRule.generated";
+import { issueSalesCreditNote } from "./command/issueSalesCreditNote.generated";
+import { issueSalesInvoice } from "./command/issueSalesInvoice.generated";
+import { markChannelOrderException } from "./command/markChannelOrderException.generated";
+import { pauseListing } from "./command/pauseListing.generated";
+import { placeSalesOrderOnCreditHold } from "./command/placeSalesOrderOnCreditHold.generated";
+import { postShipment } from "./command/postShipment.generated";
+import { recordChannelOrder } from "./command/recordChannelOrder.generated";
+import { rejectSalesOrder } from "./command/rejectSalesOrder.generated";
+import { releaseSalesOrderCreditHold } from "./command/releaseSalesOrderCreditHold.generated";
+import { retireListing } from "./command/retireListing.generated";
+import { retrySyncJob } from "./command/retrySyncJob.generated";
+import { sendSalesInvoice } from "./command/sendSalesInvoice.generated";
+import { startSyncJob } from "./command/startSyncJob.generated";
+import { submitSalesOrder } from "./command/submitSalesOrder.generated";
+import { updateChannel } from "./command/updateChannel.generated";
+import { updateListing } from "./command/updateListing.generated";
+import { updateSalesCreditNote } from "./command/updateSalesCreditNote.generated";
+import { updateSalesInvoice } from "./command/updateSalesInvoice.generated";
+import { updateSalesOrder } from "./command/updateSalesOrder.generated";
+import { updateSalesPaymentTerm } from "./command/updateSalesPaymentTerm.generated";
+import { updateSalesPriceList } from "./command/updateSalesPriceList.generated";
+import { updateSalesPriceRule } from "./command/updateSalesPriceRule.generated";
+import { updateShipment } from "./command/updateShipment.generated";
+import { createChannelType, type CreateChannelTypeParams } from "./db/channel";
+import { createChannelOrderType, type CreateChannelOrderTypeParams } from "./db/channelOrder";
+import {
+  createChannelOrderLineType,
+  type CreateChannelOrderLineTypeParams,
+} from "./db/channelOrderLine";
+import { createListingType, type CreateListingTypeParams } from "./db/listing";
+import {
+  createSalesCreditNoteType,
+  type CreateSalesCreditNoteTypeParams,
+} from "./db/salesCreditNote";
+import {
+  createSalesCreditNoteLineType,
+  type CreateSalesCreditNoteLineTypeParams,
+} from "./db/salesCreditNoteLine";
+import { createSalesInvoiceType, type CreateSalesInvoiceTypeParams } from "./db/salesInvoice";
+import {
+  createSalesInvoiceLineType,
+  type CreateSalesInvoiceLineTypeParams,
+} from "./db/salesInvoiceLine";
+import { createSalesOrderType, type CreateSalesOrderTypeParams } from "./db/salesOrder";
+import { createSalesOrderLineType, type CreateSalesOrderLineTypeParams } from "./db/salesOrderLine";
+import {
+  createSalesPaymentTermType,
+  type CreateSalesPaymentTermTypeParams,
+} from "./db/salesPaymentTerm";
+import { createSalesPriceListType, type CreateSalesPriceListTypeParams } from "./db/salesPriceList";
+import { createSalesPriceRuleType, type CreateSalesPriceRuleTypeParams } from "./db/salesPriceRule";
+import { createShipmentType, type CreateShipmentTypeParams } from "./db/shipment";
+import { createShipmentLineType, type CreateShipmentLineTypeParams } from "./db/shipmentLine";
+import { createSyncJobType, type CreateSyncJobTypeParams } from "./db/syncJob";
+import { calculateInvoiceDueSchedule } from "./query/calculateInvoiceDueSchedule.generated";
+import { getApplicableSalesPrice } from "./query/getApplicableSalesPrice.generated";
+import { getChannel } from "./query/getChannel.generated";
+import { getChannelOrder } from "./query/getChannelOrder.generated";
+import { getListing } from "./query/getListing.generated";
+import { getListingByExternalIdentifier } from "./query/getListingByExternalIdentifier.generated";
+import { getSalesCreditNote } from "./query/getSalesCreditNote.generated";
+import { getSalesInvoice } from "./query/getSalesInvoice.generated";
+import { getSalesOrder } from "./query/getSalesOrder.generated";
+import { getSalesPaymentTerm } from "./query/getSalesPaymentTerm.generated";
+import { getSalesPriceList } from "./query/getSalesPriceList.generated";
+import { getShipment } from "./query/getShipment.generated";
+import { getSyncJob } from "./query/getSyncJob.generated";
+import { listChannelOrdersByStatus } from "./query/listChannelOrdersByStatus.generated";
+import { listChannels } from "./query/listChannels.generated";
+import { listListingsByChannel } from "./query/listListingsByChannel.generated";
+import { listSalesCreditNotesByInvoice } from "./query/listSalesCreditNotesByInvoice.generated";
+import { listSalesInvoicesBySalesOrder } from "./query/listSalesInvoicesBySalesOrder.generated";
+import { listSalesOrders } from "./query/listSalesOrders.generated";
+import { listSalesPaymentTerms } from "./query/listSalesPaymentTerms.generated";
+import { listSalesPriceLists } from "./query/listSalesPriceLists.generated";
+import { listSalesPriceRulesByPriceList } from "./query/listSalesPriceRulesByPriceList.generated";
+import { listShipmentsBySalesOrder } from "./query/listShipmentsBySalesOrder.generated";
+import { listSyncJobs } from "./query/listSyncJobs.generated";
+import { type EmptyFields } from "@tailor-platform/erp-kit/module";
+
+type OrganizationModule = ReturnType<typeof defineOrganizationModule>;
+type OrganizationDB = OrganizationModule["db"];
+type BusinessPartnerModule = ReturnType<typeof defineBusinessPartnerModule>;
+type BusinessPartnerDB = BusinessPartnerModule["db"];
+type ItemManagementModule = ReturnType<typeof defineItemManagementModule>;
+type ItemManagementDB = ItemManagementModule["db"];
+type PrimitivesModule = ReturnType<typeof definePrimitivesModule>;
+type PrimitivesDB = PrimitivesModule["db"];
+
+export interface DefineModuleParams<
+  ChF extends Record<string, TailorAnyDBField> = EmptyFields,
+  LiF extends Record<string, TailorAnyDBField> = EmptyFields,
+  PtF extends Record<string, TailorAnyDBField> = EmptyFields,
+  PlF extends Record<string, TailorAnyDBField> = EmptyFields,
+  PrF extends Record<string, TailorAnyDBField> = EmptyFields,
+  SoF extends Record<string, TailorAnyDBField> = EmptyFields,
+  SolF extends Record<string, TailorAnyDBField> = EmptyFields,
+  ShF extends Record<string, TailorAnyDBField> = EmptyFields,
+  ShlF extends Record<string, TailorAnyDBField> = EmptyFields,
+  SiF extends Record<string, TailorAnyDBField> = EmptyFields,
+  SilF extends Record<string, TailorAnyDBField> = EmptyFields,
+  ScF extends Record<string, TailorAnyDBField> = EmptyFields,
+  SclF extends Record<string, TailorAnyDBField> = EmptyFields,
+  CoF extends Record<string, TailorAnyDBField> = EmptyFields,
+  ColF extends Record<string, TailorAnyDBField> = EmptyFields,
+  SjF extends Record<string, TailorAnyDBField> = EmptyFields,
+> {
+  channel?: CreateChannelTypeParams<ChF>;
+  listing?: CreateListingTypeParams<LiF>;
+  salesPaymentTerm?: CreateSalesPaymentTermTypeParams<PtF>;
+  salesPriceList?: CreateSalesPriceListTypeParams<PlF>;
+  salesPriceRule?: CreateSalesPriceRuleTypeParams<PrF>;
+  salesOrder?: CreateSalesOrderTypeParams<SoF>;
+  salesOrderLine?: CreateSalesOrderLineTypeParams<SolF>;
+  shipment?: CreateShipmentTypeParams<ShF>;
+  shipmentLine?: CreateShipmentLineTypeParams<ShlF>;
+  salesInvoice?: CreateSalesInvoiceTypeParams<SiF>;
+  salesInvoiceLine?: CreateSalesInvoiceLineTypeParams<SilF>;
+  salesCreditNote?: CreateSalesCreditNoteTypeParams<ScF>;
+  salesCreditNoteLine?: CreateSalesCreditNoteLineTypeParams<SclF>;
+  channelOrder?: CreateChannelOrderTypeParams<CoF>;
+  channelOrderLine?: CreateChannelOrderLineTypeParams<ColF>;
+  syncJob?: CreateSyncJobTypeParams<SjF>;
+  organization: {
+    db: {
+      company: OrganizationDB["company"];
+      site: OrganizationDB["site"];
+    };
+  };
+  businessPartner: {
+    db: {
+      businessPartner: BusinessPartnerDB["businessPartner"];
+      partnerRole: BusinessPartnerDB["partnerRole"];
+    };
+  };
+  itemManagement: {
+    db: {
+      item: ItemManagementDB["item"];
+    };
+  };
+  primitives: {
+    db: {
+      currency: PrimitivesDB["currency"];
+      unit: PrimitivesDB["unit"];
+    };
+  };
+}
+
+export const defineModule = <
+  const ChF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const LiF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const PtF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const PlF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const PrF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const SoF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const SolF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const ShF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const ShlF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const SiF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const SilF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const ScF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const SclF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const CoF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const ColF extends Record<string, TailorAnyDBField> = EmptyFields,
+  const SjF extends Record<string, TailorAnyDBField> = EmptyFields,
+>(
+  params: DefineModuleParams<
+    ChF,
+    LiF,
+    PtF,
+    PlF,
+    PrF,
+    SoF,
+    SolF,
+    ShF,
+    ShlF,
+    SiF,
+    SilF,
+    ScF,
+    SclF,
+    CoF,
+    ColF,
+    SjF
+  >,
+) => {
+  const channelDb = createChannelType({
+    ...params.channel,
+    companyType: params.organization.db.company,
+  });
+  const salesPaymentTermDb = createSalesPaymentTermType({
+    ...params.salesPaymentTerm,
+    companyType: params.organization.db.company,
+  });
+  const salesPriceListDb = createSalesPriceListType({
+    ...params.salesPriceList,
+    companyType: params.organization.db.company,
+    customerType: params.businessPartner.db.businessPartner,
+    channelType: channelDb,
+  });
+  const listingDb = createListingType({
+    ...params.listing,
+    companyType: params.organization.db.company,
+    channelType: channelDb,
+    itemType: params.itemManagement.db.item,
+    salesPriceListType: salesPriceListDb,
+  });
+  const salesPriceRuleDb = createSalesPriceRuleType({
+    ...params.salesPriceRule,
+    salesPriceListType: salesPriceListDb,
+    itemType: params.itemManagement.db.item,
+    customerType: params.businessPartner.db.businessPartner,
+    channelType: channelDb,
+    currencyType: params.primitives.db.currency,
+    unitType: params.primitives.db.unit,
+  });
+  const salesOrderDb = createSalesOrderType({
+    ...params.salesOrder,
+    companyType: params.organization.db.company,
+    customerType: params.businessPartner.db.businessPartner,
+    channelType: channelDb,
+    paymentTermType: salesPaymentTermDb,
+  });
+  const salesOrderLineDb = createSalesOrderLineType({
+    ...params.salesOrderLine,
+    salesOrderType: salesOrderDb,
+    itemType: params.itemManagement.db.item,
+    currencyType: params.primitives.db.currency,
+    unitType: params.primitives.db.unit,
+    salesPriceRuleType: salesPriceRuleDb,
+  });
+  const shipmentDb = createShipmentType({
+    ...params.shipment,
+    companyType: params.organization.db.company,
+    salesOrderType: salesOrderDb,
+    customerType: params.businessPartner.db.businessPartner,
+    siteType: params.organization.db.site,
+  });
+  const shipmentLineDb = createShipmentLineType({
+    ...params.shipmentLine,
+    shipmentType: shipmentDb,
+    salesOrderLineType: salesOrderLineDb,
+    unitType: params.primitives.db.unit,
+  });
+  const salesInvoiceDb = createSalesInvoiceType({
+    ...params.salesInvoice,
+    companyType: params.organization.db.company,
+    customerType: params.businessPartner.db.businessPartner,
+    salesOrderType: salesOrderDb,
+    paymentTermType: salesPaymentTermDb,
+    shipmentType: shipmentDb,
+  });
+  const salesInvoiceLineDb = createSalesInvoiceLineType({
+    ...params.salesInvoiceLine,
+    salesInvoiceType: salesInvoiceDb,
+    salesOrderLineType: salesOrderLineDb,
+    shipmentLineType: shipmentLineDb,
+  });
+  const salesCreditNoteDb = createSalesCreditNoteType({
+    ...params.salesCreditNote,
+    companyType: params.organization.db.company,
+    customerType: params.businessPartner.db.businessPartner,
+    salesInvoiceType: salesInvoiceDb,
+  });
+  const salesCreditNoteLineDb = createSalesCreditNoteLineType({
+    ...params.salesCreditNoteLine,
+    salesCreditNoteType: salesCreditNoteDb,
+    salesInvoiceLineType: salesInvoiceLineDb,
+  });
+  const syncJobDb = createSyncJobType({
+    ...params.syncJob,
+    companyType: params.organization.db.company,
+    channelType: channelDb,
+  });
+  const channelOrderDb = createChannelOrderType({
+    ...params.channelOrder,
+    companyType: params.organization.db.company,
+    channelType: channelDb,
+    customerType: params.businessPartner.db.businessPartner,
+    salesOrderType: salesOrderDb,
+    currencyType: params.primitives.db.currency,
+    syncJobType: syncJobDb,
+  });
+  const channelOrderLineDb = createChannelOrderLineType({
+    ...params.channelOrderLine,
+    channelOrderType: channelOrderDb,
+    listingType: listingDb,
+    itemType: params.itemManagement.db.item,
+    currencyType: params.primitives.db.currency,
+    unitType: params.primitives.db.unit,
+  });
+
+  return {
+    db: {
+      channel: channelDb,
+      listing: listingDb,
+      salesPaymentTerm: salesPaymentTermDb,
+      salesPriceList: salesPriceListDb,
+      salesPriceRule: salesPriceRuleDb,
+      salesOrder: salesOrderDb,
+      salesOrderLine: salesOrderLineDb,
+      shipment: shipmentDb,
+      shipmentLine: shipmentLineDb,
+      salesInvoice: salesInvoiceDb,
+      salesInvoiceLine: salesInvoiceLineDb,
+      salesCreditNote: salesCreditNoteDb,
+      salesCreditNoteLine: salesCreditNoteLineDb,
+      channelOrder: channelOrderDb,
+      channelOrderLine: channelOrderLineDb,
+      syncJob: syncJobDb,
+    },
+    commands: {
+      activateChannel: activateChannel(),
+      activateListing: activateListing(),
+      activateSalesPaymentTerm: activateSalesPaymentTerm(),
+      activateSalesPriceList: activateSalesPriceList(),
+      activateSalesPriceRule: activateSalesPriceRule(),
+      cancelChannelOrder: cancelChannelOrder(),
+      cancelSalesInvoice: cancelSalesInvoice(),
+      cancelSalesOrder: cancelSalesOrder(),
+      cancelSyncJob: cancelSyncJob(),
+      closeSalesOrder: closeSalesOrder(),
+      confirmSalesOrder: confirmSalesOrder(),
+      convertChannelOrder: convertChannelOrder(),
+      createChannel: createChannel(),
+      createListing: createListing(),
+      createSalesCreditNote: createSalesCreditNote(),
+      createSalesInvoice: createSalesInvoice(),
+      createSalesOrder: createSalesOrder(),
+      createSalesPaymentTerm: createSalesPaymentTerm(),
+      createSalesPriceList: createSalesPriceList(),
+      createSalesPriceRule: createSalesPriceRule(),
+      createShipment: createShipment(),
+      deactivateChannel: deactivateChannel(),
+      deactivateSalesPaymentTerm: deactivateSalesPaymentTerm(),
+      deactivateSalesPriceList: deactivateSalesPriceList(),
+      deactivateSalesPriceRule: deactivateSalesPriceRule(),
+      issueSalesCreditNote: issueSalesCreditNote(),
+      issueSalesInvoice: issueSalesInvoice(),
+      markChannelOrderException: markChannelOrderException(),
+      pauseListing: pauseListing(),
+      placeSalesOrderOnCreditHold: placeSalesOrderOnCreditHold(),
+      postShipment: postShipment(),
+      recordChannelOrder: recordChannelOrder(),
+      rejectSalesOrder: rejectSalesOrder(),
+      releaseSalesOrderCreditHold: releaseSalesOrderCreditHold(),
+      retireListing: retireListing(),
+      retrySyncJob: retrySyncJob(),
+      sendSalesInvoice: sendSalesInvoice(),
+      startSyncJob: startSyncJob(),
+      submitSalesOrder: submitSalesOrder(),
+      updateChannel: updateChannel(),
+      updateListing: updateListing(),
+      updateSalesCreditNote: updateSalesCreditNote(),
+      updateSalesInvoice: updateSalesInvoice(),
+      updateSalesOrder: updateSalesOrder(),
+      updateSalesPaymentTerm: updateSalesPaymentTerm(),
+      updateSalesPriceList: updateSalesPriceList(),
+      updateSalesPriceRule: updateSalesPriceRule(),
+      updateShipment: updateShipment(),
+    },
+    queries: {
+      calculateInvoiceDueSchedule,
+      getApplicableSalesPrice,
+      getChannel,
+      getChannelOrder,
+      getListing,
+      getListingByExternalIdentifier,
+      getSalesCreditNote,
+      getSalesInvoice,
+      getSalesOrder,
+      getSalesPaymentTerm,
+      getSalesPriceList,
+      getShipment,
+      getSyncJob,
+      listChannelOrdersByStatus,
+      listChannels,
+      listListingsByChannel,
+      listSalesCreditNotesByInvoice,
+      listSalesInvoicesBySalesOrder,
+      listSalesOrders,
+      listSalesPaymentTerms,
+      listSalesPriceLists,
+      listSalesPriceRulesByPriceList,
+      listShipmentsBySalesOrder,
+      listSyncJobs,
+    },
+  };
+};

package/src/modules/sales/permissions.ts

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

package/src/modules/sales/query/calculateInvoiceDueSchedule.generated.ts

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

package/src/modules/sales/query/calculateInvoiceDueSchedule.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { InvalidPaymentTermDefinitionError } from "../lib/errors.generated";
+import { encodeJson, type DueScheduleLine, type PaymentTermScheduleLineInput } from "../lib/domain";
+import {
+  basePaymentTerm,
+  installmentScheduleLines,
+  endOfMonthScheduleLines,
+} from "../testing/fixtures";
+import { expectErr, expectOk } from "../testing/commandTestUtils";
+import { run } from "./calculateInvoiceDueSchedule";
+
+const invoiceDate = new Date("2024-02-15T00:00:00.000Z");
+
+describe("calculateInvoiceDueSchedule", () => {
+  it("calculates net-day due schedule", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(basePaymentTerm);
+
+    const result = await run(db, {
+      paymentTermId: basePaymentTerm.id,
+      invoiceDate,
+      invoiceAmount: 1000,
+    });
+    const { dueSchedule } = expectOk<{ dueSchedule: DueScheduleLine[] }>(result as never);
+
+    expect(dueSchedule).toHaveLength(1);
+    expect(dueSchedule[0]).toMatchObject({
+      amount: 1000,
+      dueDate: new Date("2024-03-16T00:00:00.000Z"),
+    });
+  });
+
+  it("calculates installment due schedule", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const installmentTerm = {
+      ...basePaymentTerm,
+      id: "payment-term-installment",
+      scheduleLines: encodeJson(installmentScheduleLines),
+    };
+    spies.select.mockReturnValueOnce(installmentTerm);
+
+    const result = await run(db, {
+      paymentTermId: installmentTerm.id,
+      invoiceDate,
+      invoiceAmount: 1000,
+    });
+    const { dueSchedule } = expectOk<{ dueSchedule: DueScheduleLine[] }>(result as never);
+
+    expect(dueSchedule).toHaveLength(2);
+    expect(dueSchedule[0]).toMatchObject({
+      amount: 500,
+      dueDate: new Date("2024-03-01T00:00:00.000Z"),
+    });
+    expect(dueSchedule[1]).toMatchObject({
+      amount: 500,
+      dueDate: new Date("2024-03-16T00:00:00.000Z"),
+    });
+  });
+
+  it("calculates end-of-month due schedule", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const eomTerm = {
+      ...basePaymentTerm,
+      id: "payment-term-eom",
+      scheduleLines: encodeJson(endOfMonthScheduleLines),
+    };
+    spies.select.mockReturnValueOnce(eomTerm);
+
+    const result = await run(db, {
+      paymentTermId: eomTerm.id,
+      invoiceDate,
+      invoiceAmount: 500,
+    });
+    const { dueSchedule } = expectOk<{ dueSchedule: DueScheduleLine[] }>(result as never);
+
+    expect(dueSchedule).toHaveLength(1);
+    // End of February 2024 (leap year) → Feb 29
+    expect(dueSchedule[0]).toMatchObject({
+      amount: 500,
+      dueDate: new Date("2024-02-29T00:00:00.000Z"),
+    });
+  });
+
+  it("throws when payment term definition is invalid", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const invalidLines: PaymentTermScheduleLineInput[] = [
+      { kind: "INSTALLMENT", days: 15, percentage: 40 },
+      { kind: "INSTALLMENT", days: 30, percentage: 40 },
+    ];
+    const invalidTerm = {
+      ...basePaymentTerm,
+      id: "payment-term-invalid",
+      scheduleLines: encodeJson(invalidLines),
+    };
+    spies.select.mockReturnValueOnce(invalidTerm);
+
+    const result = await run(db, {
+      paymentTermId: invalidTerm.id,
+      invoiceDate,
+      invoiceAmount: 1000,
+    });
+
+    expectErr(result as never, InvalidPaymentTermDefinitionError);
+  });
+});

package/src/modules/sales/query/calculateInvoiceDueSchedule.ts

@@ -0,0 +1,35 @@
+import type { DB } from "../generated/kysely-tailordb";
+import {
+  InvalidPaymentTermDefinitionError,
+  PaymentTermNotFoundError,
+} from "../lib/errors.generated";
+import { calculateDueSchedule, decodeJson, type PaymentTermScheduleLineInput } from "../lib/domain";
+import { err, ok, type ReadonlyDB } from "@tailor-platform/erp-kit/module";
+
+export interface CalculateInvoiceDueScheduleInput {
+  paymentTermId: string;
+  invoiceDate: Date;
+  invoiceAmount?: number;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: CalculateInvoiceDueScheduleInput) {
+  const paymentTerm = await db
+    .selectFrom("SalesPaymentTerm")
+    .selectAll()
+    .where("id", "=", input.paymentTermId)
+    .executeTakeFirst();
+  if (!paymentTerm) {
+    return err(new PaymentTermNotFoundError(input.paymentTermId));
+  }
+
+  const dueSchedule = calculateDueSchedule(
+    decodeJson<PaymentTermScheduleLineInput[]>(paymentTerm.scheduleLines, []),
+    input.invoiceDate,
+    input.invoiceAmount ?? 0,
+  );
+  if (!dueSchedule) {
+    return err(new InvalidPaymentTermDefinitionError(input.paymentTermId));
+  }
+
+  return ok({ dueSchedule });
+}