@tailor-platform/erp-kit 0.4.0 → 0.5.0

package/src/modules/sales/command/updateShipment.ts

@@ -0,0 +1,84 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  InvalidShipmentLineError,
+  ShipmentNotEditableError,
+  ShipmentNotFoundError,
+} from "../lib/errors.generated";
+import { encodeJson, type ShipmentLineInput } from "../lib/domain";
+import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface UpdateShipmentInput {
+  shipmentId: string;
+  shipFromSiteId?: string | null;
+  trackingNumber?: string | null;
+  shippingAddressSnapshot?: Record<string, unknown> | null;
+  lines?: ShipmentLineInput[];
+}
+
+export async function run(db: Transaction, input: UpdateShipmentInput, ctx: CommandContext) {
+  void ctx;
+  const shipment = await db
+    .selectFrom("Shipment")
+    .selectAll()
+    .where("id", "=", input.shipmentId)
+    .forUpdate()
+    .executeTakeFirst();
+  if (!shipment) {
+    return err(new ShipmentNotFoundError(input.shipmentId));
+  }
+  if (shipment.status !== "DRAFT") {
+    return err(new ShipmentNotEditableError(input.shipmentId));
+  }
+  if (input.lines) {
+    for (const line of input.lines) {
+      const orderLine = await db
+        .selectFrom("SalesOrderLine")
+        .selectAll()
+        .where("id", "=", line.salesOrderLineId)
+        .executeTakeFirst();
+      if (orderLine?.salesOrderId !== shipment.salesOrderId || line.quantity <= 0) {
+        return err(new InvalidShipmentLineError(input.shipmentId));
+      }
+      if (orderLine.quantity - orderLine.shippedQuantity < line.quantity) {
+        return err(new InvalidShipmentLineError(input.shipmentId));
+      }
+    }
+  }
+  const updated = await db
+    .updateTable("Shipment")
+    .set({
+      shipFromSiteId:
+        input.shipFromSiteId === undefined ? shipment.shipFromSiteId : input.shipFromSiteId,
+      trackingNumber:
+        input.trackingNumber === undefined ? shipment.trackingNumber : input.trackingNumber,
+      shippingAddressSnapshot:
+        input.shippingAddressSnapshot === undefined
+          ? shipment.shippingAddressSnapshot
+          : input.shippingAddressSnapshot
+            ? encodeJson(input.shippingAddressSnapshot)
+            : null,
+      updatedAt: new Date(),
+    })
+    .where("id", "=", input.shipmentId)
+    .returningAll()
+    .executeTakeFirst();
+  if (input.lines) {
+    await db.deleteFrom("ShipmentLine").where("shipmentId", "=", input.shipmentId).execute();
+    for (const line of input.lines) {
+      await db
+        .insertInto("ShipmentLine")
+        .values({
+          shipmentId: input.shipmentId,
+          salesOrderLineId: line.salesOrderLineId,
+          quantity: line.quantity,
+          unitId: line.unitId ?? null,
+          trackingReference: line.trackingReference ?? null,
+          requiresInventoryHandoff: line.requiresInventoryHandoff ?? true,
+          createdAt: new Date(),
+          updatedAt: null,
+        })
+        .executeTakeFirst();
+    }
+  }
+  return ok({ shipment: updated! });
+}

package/src/modules/sales/db/channel.ts

@@ -0,0 +1,43 @@
+import {
+  db,
+  type TailorAnyDBField,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { company as companyStub } from "../lib/_db_deps";
+
+export const CHANNEL_STATUSES: [string, string, string] = ["DRAFT", "ACTIVE", "INACTIVE"];
+
+export interface CreateChannelTypeParams<F extends Record<string, TailorAnyDBField>> {
+  fields?: F;
+  companyType?: TailorAnyDBType;
+}
+
+export function createChannelType<const F extends Record<string, TailorAnyDBField>>(
+  params: CreateChannelTypeParams<F>,
+) {
+  return db
+    .type("Channel", {
+      companyId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.companyType ?? companyStub },
+          backward: "channels",
+        })
+        .description("Foreign key to Company"),
+      type: db.string().description("Channel integration type"),
+      name: db.string().description("Human-readable channel name"),
+      code: db.string({ optional: true }).description("Optional short code"),
+      status: db.enum(CHANNEL_STATUSES).description("Channel lifecycle status"),
+      settings: db.string({ optional: true }).description("Serialized channel settings"),
+      lastSyncAt: db.date({ optional: true }).description("Last sync timestamp"),
+      ...((params.fields ?? {}) as F),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const channel = createChannelType({});

package/src/modules/sales/db/channelOrder.ts

@@ -0,0 +1,109 @@
+import {
+  db,
+  type TailorAnyDBField,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import {
+  businessPartner as businessPartnerStub,
+  company as companyStub,
+  currency as currencyStub,
+} from "../lib/_db_deps";
+import { channel } from "./channel";
+import { salesOrder } from "./salesOrder";
+import { syncJob } from "./syncJob";
+
+export const CHANNEL_ORDER_STATUSES: [string, string, string, string] = [
+  "PENDING_CONVERSION",
+  "CONVERTED",
+  "EXCEPTION",
+  "CANCELLED_BY_CHANNEL",
+];
+
+export interface CreateChannelOrderTypeParams<F extends Record<string, TailorAnyDBField>> {
+  fields?: F;
+  companyType?: TailorAnyDBType;
+  channelType?: TailorAnyDBType;
+  customerType?: TailorAnyDBType;
+  salesOrderType?: TailorAnyDBType;
+  currencyType?: TailorAnyDBType;
+  syncJobType?: TailorAnyDBType;
+}
+
+export function createChannelOrderType<const F extends Record<string, TailorAnyDBField>>(
+  params: CreateChannelOrderTypeParams<F>,
+) {
+  return db
+    .type("ChannelOrder", {
+      companyId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.companyType ?? companyStub },
+          backward: "channelOrders",
+        })
+        .description("Foreign key to Company"),
+      channelId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.channelType ?? channel },
+          backward: "channelOrders",
+        })
+        .description("Foreign key to Channel"),
+      externalOrderId: db.string().description("External order identifier"),
+      externalCustomerId: db.string({ optional: true }).description("External buyer identifier"),
+      customerId: db
+        .uuid({ optional: true })
+        .relation({
+          type: "n-1",
+          toward: { type: params.customerType ?? businessPartnerStub },
+          backward: "channelOrders",
+        })
+        .description("Optional mapped customer"),
+      salesOrderId: db
+        .uuid({ optional: true })
+        .relation({
+          type: "n-1",
+          toward: { type: params.salesOrderType ?? salesOrder },
+          backward: "channelOrders",
+        })
+        .description("Optional linked SalesOrder"),
+      status: db.enum(CHANNEL_ORDER_STATUSES).description("Channel-order lifecycle status"),
+      orderDate: db.date({ optional: true }).description("Channel order date"),
+      currencyId: db
+        .uuid({ optional: true })
+        .relation({
+          type: "n-1",
+          toward: { type: params.currencyType ?? currencyStub },
+          backward: "channelOrders",
+        })
+        .description("Optional mapped currency"),
+      rawPayload: db.string({ optional: true }).description("Serialized raw inbound payload"),
+      normalizedPayload: db
+        .string({ optional: true })
+        .description("Serialized normalized channel-order payload"),
+      errorSummary: db.string({ optional: true }).description("Latest exception summary"),
+      retryContext: db.string({ optional: true }).description("Serialized retry context"),
+      syncJobId: db
+        .uuid({ optional: true })
+        .relation({
+          type: "n-1",
+          toward: { type: params.syncJobType ?? syncJob },
+          backward: "channelOrders",
+        })
+        .description("Optional originating SyncJob"),
+      ...((params.fields ?? {}) as F),
+      ...db.fields.timestamps(),
+    })
+    .indexes({
+      fields: ["companyId", "channelId", "externalOrderId"],
+      unique: true,
+      name: "channel_order_company_channel_external_idx",
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const channelOrder = createChannelOrderType({});

package/src/modules/sales/db/channelOrderLine.ts

@@ -0,0 +1,84 @@
+import {
+  db,
+  type TailorAnyDBField,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { currency as currencyStub, item as itemStub, unit as unitStub } from "../lib/_db_deps";
+import { channelOrder } from "./channelOrder";
+import { listing } from "./listing";
+
+export interface CreateChannelOrderLineTypeParams<F extends Record<string, TailorAnyDBField>> {
+  fields?: F;
+  channelOrderType?: TailorAnyDBType;
+  listingType?: TailorAnyDBType;
+  itemType?: TailorAnyDBType;
+  currencyType?: TailorAnyDBType;
+  unitType?: TailorAnyDBType;
+}
+
+export function createChannelOrderLineType<const F extends Record<string, TailorAnyDBField>>(
+  params: CreateChannelOrderLineTypeParams<F>,
+) {
+  return db
+    .type("ChannelOrderLine", {
+      channelOrderId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.channelOrderType ?? channelOrder },
+          backward: "lines",
+        })
+        .description("Foreign key to ChannelOrder"),
+      externalLineId: db
+        .string({ optional: true })
+        .description("Optional external line identifier"),
+      listingId: db
+        .uuid({ optional: true })
+        .relation({
+          type: "n-1",
+          toward: { type: params.listingType ?? listing },
+          backward: "channelOrderLines",
+        })
+        .description("Optional mapped Listing"),
+      itemId: db
+        .uuid({ optional: true })
+        .relation({
+          type: "n-1",
+          toward: { type: params.itemType ?? itemStub },
+          backward: "channelOrderLines",
+        })
+        .description("Optional resolved Item"),
+      description: db
+        .string({ optional: true })
+        .description("Optional normalized line description"),
+      quantity: db.float().description("Normalized ordered quantity"),
+      unitPrice: db.float({ optional: true }).description("Optional normalized unit price"),
+      currencyId: db
+        .uuid({ optional: true })
+        .relation({
+          type: "n-1",
+          toward: { type: params.currencyType ?? currencyStub },
+          backward: "channelOrderLines",
+        })
+        .description("Optional mapped currency"),
+      unitId: db
+        .uuid({ optional: true })
+        .relation({
+          type: "n-1",
+          toward: { type: params.unitType ?? unitStub },
+          backward: "channelOrderLines",
+        })
+        .description("Optional mapped unit of measure"),
+      rawPayload: db
+        .string({ optional: true })
+        .description("Optional serialized normalized line payload"),
+      ...((params.fields ?? {}) as F),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const channelOrderLine = createChannelOrderLineType({});

package/src/modules/sales/db/listing.ts

@@ -0,0 +1,81 @@
+import {
+  db,
+  type TailorAnyDBField,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { company as companyStub, item as itemStub } from "../lib/_db_deps";
+import { channel } from "./channel";
+import { salesPriceList } from "./salesPriceList";
+
+export const LISTING_STATUSES: [string, string, string, string] = [
+  "DRAFT",
+  "ACTIVE",
+  "PAUSED",
+  "RETIRED",
+];
+
+export interface CreateListingTypeParams<F extends Record<string, TailorAnyDBField>> {
+  fields?: F;
+  companyType?: TailorAnyDBType;
+  channelType?: TailorAnyDBType;
+  itemType?: TailorAnyDBType;
+  salesPriceListType?: TailorAnyDBType;
+}
+
+export function createListingType<const F extends Record<string, TailorAnyDBField>>(
+  params: CreateListingTypeParams<F>,
+) {
+  return db
+    .type("Listing", {
+      companyId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.companyType ?? companyStub },
+          backward: "listings",
+        })
+        .description("Foreign key to Company"),
+      channelId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.channelType ?? channel },
+          backward: "listings",
+        })
+        .description("Foreign key to Channel"),
+      itemId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.itemType ?? itemStub },
+          backward: "listings",
+        })
+        .description("Foreign key to Item"),
+      sku: db.string({ optional: true }).description("Optional internal listing SKU"),
+      externalIdentifier: db.string({ optional: true }).description("External listing identifier"),
+      title: db.string({ optional: true }).description("Listing title"),
+      status: db.enum(LISTING_STATUSES).description("Listing lifecycle status"),
+      requiresPriceSync: db.bool().description("Whether active pricing linkage is required"),
+      salesPriceListId: db
+        .uuid({ optional: true })
+        .relation({
+          type: "n-1",
+          toward: { type: params.salesPriceListType ?? salesPriceList },
+          backward: "listings",
+        })
+        .description("Optional linked SalesPriceList"),
+      ...((params.fields ?? {}) as F),
+      ...db.fields.timestamps(),
+    })
+    .indexes({
+      fields: ["channelId", "externalIdentifier"],
+      unique: true,
+      name: "listing_channel_external_identifier_idx",
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const listing = createListingType({});

package/src/modules/sales/db/salesCreditNote.ts

@@ -0,0 +1,63 @@
+import {
+  db,
+  type TailorAnyDBField,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { businessPartner as businessPartnerStub, company as companyStub } from "../lib/_db_deps";
+import { salesInvoice } from "./salesInvoice";
+
+export const SALES_CREDIT_NOTE_STATUSES: [string, string] = ["DRAFT", "ISSUED"];
+
+export interface CreateSalesCreditNoteTypeParams<F extends Record<string, TailorAnyDBField>> {
+  fields?: F;
+  companyType?: TailorAnyDBType;
+  customerType?: TailorAnyDBType;
+  salesInvoiceType?: TailorAnyDBType;
+}
+
+export function createSalesCreditNoteType<const F extends Record<string, TailorAnyDBField>>(
+  params: CreateSalesCreditNoteTypeParams<F>,
+) {
+  return db
+    .type("SalesCreditNote", {
+      companyId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.companyType ?? companyStub },
+          backward: "salesCreditNotes",
+        })
+        .description("Foreign key to Company"),
+      customerId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.customerType ?? businessPartnerStub },
+          backward: "salesCreditNotes",
+        })
+        .description("Foreign key to Customer"),
+      salesInvoiceId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.salesInvoiceType ?? salesInvoice },
+          backward: "salesCreditNotes",
+        })
+        .description("Foreign key to SalesInvoice"),
+      status: db.enum(SALES_CREDIT_NOTE_STATUSES).description("Credit-note lifecycle status"),
+      creditNoteNumber: db.string({ optional: true }).description("Optional document number"),
+      creditDate: db.date().description("Credit-note date"),
+      reason: db.string({ optional: true }).description("Correction reason"),
+      correctionSnapshot: db
+        .string({ optional: true })
+        .description("Serialized correction snapshot context"),
+      ...((params.fields ?? {}) as F),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const salesCreditNote = createSalesCreditNoteType({});

package/src/modules/sales/db/salesCreditNoteLine.ts

@@ -0,0 +1,49 @@
+import {
+  db,
+  type TailorAnyDBField,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { salesCreditNote } from "./salesCreditNote";
+import { salesInvoiceLine } from "./salesInvoiceLine";
+
+export interface CreateSalesCreditNoteLineTypeParams<F extends Record<string, TailorAnyDBField>> {
+  fields?: F;
+  salesCreditNoteType?: TailorAnyDBType;
+  salesInvoiceLineType?: TailorAnyDBType;
+}
+
+export function createSalesCreditNoteLineType<const F extends Record<string, TailorAnyDBField>>(
+  params: CreateSalesCreditNoteLineTypeParams<F>,
+) {
+  return db
+    .type("SalesCreditNoteLine", {
+      salesCreditNoteId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.salesCreditNoteType ?? salesCreditNote },
+          backward: "lines",
+        })
+        .description("Foreign key to SalesCreditNote"),
+      salesInvoiceLineId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.salesInvoiceLineType ?? salesInvoiceLine },
+          backward: "creditNoteLines",
+        })
+        .description("Foreign key to SalesInvoiceLine"),
+      quantity: db.float({ optional: true }).description("Credited quantity"),
+      amount: db.float({ optional: true }).description("Credited amount"),
+      reason: db.string({ optional: true }).description("Line-level correction reason"),
+      taxAmount: db.float({ optional: true }).description("Credited tax amount"),
+      ...((params.fields ?? {}) as F),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const salesCreditNoteLine = createSalesCreditNoteLineType({});

package/src/modules/sales/db/salesInvoice.ts

@@ -0,0 +1,95 @@
+import {
+  db,
+  type TailorAnyDBField,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { businessPartner as businessPartnerStub, company as companyStub } from "../lib/_db_deps";
+import { salesOrder } from "./salesOrder";
+import { salesPaymentTerm } from "./salesPaymentTerm";
+import { shipment } from "./shipment";
+
+export const SALES_INVOICE_STATUSES: [string, string, string, string] = [
+  "DRAFT",
+  "ISSUED",
+  "SENT",
+  "CANCELLED",
+];
+
+export interface CreateSalesInvoiceTypeParams<F extends Record<string, TailorAnyDBField>> {
+  fields?: F;
+  companyType?: TailorAnyDBType;
+  customerType?: TailorAnyDBType;
+  salesOrderType?: TailorAnyDBType;
+  paymentTermType?: TailorAnyDBType;
+  shipmentType?: TailorAnyDBType;
+}
+
+export function createSalesInvoiceType<const F extends Record<string, TailorAnyDBField>>(
+  params: CreateSalesInvoiceTypeParams<F>,
+) {
+  return db
+    .type("SalesInvoice", {
+      companyId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.companyType ?? companyStub },
+          backward: "salesInvoices",
+        })
+        .description("Foreign key to Company"),
+      customerId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.customerType ?? businessPartnerStub },
+          backward: "salesInvoices",
+        })
+        .description("Foreign key to Customer"),
+      salesOrderId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.salesOrderType ?? salesOrder },
+          backward: "salesInvoices",
+        })
+        .description("Foreign key to SalesOrder"),
+      paymentTermId: db
+        .uuid({ optional: true })
+        .relation({
+          type: "n-1",
+          toward: { type: params.paymentTermType ?? salesPaymentTerm },
+          backward: "salesInvoices",
+        })
+        .description("Optional payment term"),
+      shipmentId: db
+        .uuid({ optional: true })
+        .relation({
+          type: "n-1",
+          toward: { type: params.shipmentType ?? shipment },
+          backward: "salesInvoices",
+        })
+        .description("Optional shipment evidence"),
+      status: db.enum(SALES_INVOICE_STATUSES).description("Sales-invoice lifecycle status"),
+      invoiceNumber: db.string({ optional: true }).description("Optional invoice number"),
+      invoiceDate: db.date().description("Invoice date"),
+      billingPolicy: db.string({ optional: true }).description("Invoice billing policy"),
+      paymentTermSnapshot: db
+        .string({ optional: true })
+        .description("Serialized payment-term snapshot"),
+      dueSchedule: db.string({ optional: true }).description("Serialized due schedule"),
+      taxIdentitySnapshot: db
+        .string({ optional: true })
+        .description("Serialized tax identity snapshot"),
+      deliveryMetadata: db.string({ optional: true }).description("Serialized delivery metadata"),
+      arHandoffAccepted: db.bool().description("Whether AR handoff already accepted the invoice"),
+      notes: db.string({ optional: true }).description("Optional notes"),
+      ...((params.fields ?? {}) as F),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const salesInvoice = createSalesInvoiceType({});

package/src/modules/sales/db/salesInvoiceLine.ts

@@ -0,0 +1,64 @@
+import {
+  db,
+  type TailorAnyDBField,
+  type TailorAnyDBType,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { salesInvoice } from "./salesInvoice";
+import { salesOrderLine } from "./salesOrderLine";
+import { shipmentLine } from "./shipmentLine";
+
+export interface CreateSalesInvoiceLineTypeParams<F extends Record<string, TailorAnyDBField>> {
+  fields?: F;
+  salesInvoiceType?: TailorAnyDBType;
+  salesOrderLineType?: TailorAnyDBType;
+  shipmentLineType?: TailorAnyDBType;
+}
+
+export function createSalesInvoiceLineType<const F extends Record<string, TailorAnyDBField>>(
+  params: CreateSalesInvoiceLineTypeParams<F>,
+) {
+  return db
+    .type("SalesInvoiceLine", {
+      salesInvoiceId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.salesInvoiceType ?? salesInvoice },
+          backward: "lines",
+        })
+        .description("Foreign key to SalesInvoice"),
+      salesOrderLineId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: params.salesOrderLineType ?? salesOrderLine },
+          backward: "invoiceLines",
+        })
+        .description("Foreign key to SalesOrderLine"),
+      shipmentLineId: db
+        .uuid({ optional: true })
+        .relation({
+          type: "n-1",
+          toward: { type: params.shipmentLineType ?? shipmentLine },
+          backward: "invoiceLines",
+        })
+        .description("Optional shipment evidence line"),
+      quantity: db.float().description("Billed quantity"),
+      unitPrice: db.float().description("Billed unit price"),
+      taxCode: db.string({ optional: true }).description("Optional tax code"),
+      taxableAmount: db.float({ optional: true }).description("Taxable amount"),
+      taxAmount: db.float({ optional: true }).description("Tax amount"),
+      billingPolicy: db.string({ optional: true }).description("Line billing policy"),
+      orderPriceSnapshot: db
+        .string({ optional: true })
+        .description("Serialized order price snapshot"),
+      ...((params.fields ?? {}) as F),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const salesInvoiceLine = createSalesInvoiceLineType({});