rerobe-js-orm 4.8.8 → 4.9.0

package/lib/models/Product.js

@@ -2,8 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const Base_1 = require("../Base");
 const product_constants_1 = require("../constants/product-constants");
+const marketplace_constants_1 = require("../constants/marketplace-constants");
 const options_1 = require("../form-states/Product/options");
 const ReRobeProductHelpers_1 = require("../helpers/ReRobeProductHelpers");
+const MarketplaceProductHelpers_1 = require("../helpers/MarketplaceProductHelpers");
+const PricingHelpers_1 = require("../helpers/PricingHelpers");
+const ProductSkuHelpers_1 = require("../helpers/ProductSkuHelpers");
 class Product extends Base_1.default {
     constructor(props) {
         super();
@@ -44,6 +48,7 @@ class Product extends Base_1.default {
             isTaxable: (props === null || props === void 0 ? void 0 : props.isTaxable) || '',
             taxCategory: (props === null || props === void 0 ? void 0 : props.taxCategory) || 'STANDARD',
             productClass: (props === null || props === void 0 ? void 0 : props.productClass) || 'UNIQUE',
+            marketplace: MarketplaceProductHelpers_1.default.normalizeMarketplace(props === null || props === void 0 ? void 0 : props.marketplace),
         };
         this.filterAttributes = {
             documentId: (props === null || props === void 0 ? void 0 : props.documentId) || this.utilities.makeRandId(28),
@@ -164,6 +169,112 @@ class Product extends Base_1.default {
         }
         return obj;
     }
+    // True for retail products that should be treated as having indefinite
+    // stock (cafe items, services, etc.). The web app marks these by writing
+    // `stockStatus = 'IN_STOCK_UNLIMITED'` on the product when the merchant
+    // toggles "Track stock" off in retail quick entry. Ordering, refund, and
+    // payout flows must skip per-location quantity decrements/restores when
+    // this returns true. Mirrors the legacy backend `isUntrackedStockProduct`
+    // shim so it lives in one place.
+    isUntrackedStock() {
+        return String(this.filterAttributes.stockStatus || '').trim() === marketplace_constants_1.STOCK_STATUSES.inStockUnlimited;
+    }
+    // Marketplace listing accessors — all return safe empty values when the
+    // product has no marketplace metadata, so legacy products are unaffected.
+    hasActiveMarketplaceListing() {
+        return this.getActiveMarketplaceListings().length > 0;
+    }
+    getActiveMarketplaceListings() {
+        const marketplace = MarketplaceProductHelpers_1.default.normalizeMarketplace(this.attributes.marketplace);
+        return Object.keys(marketplace.listings)
+            .map((parentMarketplaceId) => ({ parentMarketplaceId, listing: marketplace.listings[parentMarketplaceId] }))
+            .filter(({ listing }) => listing && listing.status !== marketplace_constants_1.MARKETPLACE_LISTING_STATUSES.removed);
+    }
+    getMarketplaceListingForParent(parentMarketplaceId) {
+        if (!parentMarketplaceId)
+            return null;
+        const marketplace = MarketplaceProductHelpers_1.default.normalizeMarketplace(this.attributes.marketplace);
+        return marketplace.listings[parentMarketplaceId] || null;
+    }
+    isMarketplaceVisibleTo(parentMarketplaceId) {
+        const listing = this.getMarketplaceListingForParent(parentMarketplaceId);
+        if (!listing)
+            return false;
+        return listing.status !== marketplace_constants_1.MARKETPLACE_LISTING_STATUSES.removed;
+    }
+    // Pricing accessors. Resolve once for the merchant's country and project
+    // every price-like field into both stored (net) and displayable (gross)
+    // forms. Backwards-compatible: legacy callers that read raw
+    // `attributes.price` continue to work; new callers can use these to get
+    // a single source of truth for gross/net display math without hand-
+    // rolling tax-rate lookups in every UI/service.
+    getResolvedTaxRate(countryCode) {
+        return PricingHelpers_1.default.resolveTaxRate({
+            countryCode,
+            taxCategory: this.attributes.taxCategory,
+            isTaxable: this.attributes.isTaxable,
+        });
+    }
+    getPricing(countryCode) {
+        return PricingHelpers_1.default.getProductPricing({
+            isTaxable: this.attributes.isTaxable,
+            taxCategory: this.attributes.taxCategory,
+            price: this.attributes.price,
+            salePrice: this.consignmentAttributes.salePrice,
+            compareAtPrice: this.attributes.compareAtPrice,
+            costPerItem: this.attributes.costPerItem,
+        }, { countryCode });
+    }
+    getVariantPricing(variantId, countryCode) {
+        const variants = (this.attributes.variantInventory || []);
+        const variant = variants.find((v) => v && v.id === variantId);
+        if (!variant)
+            return null;
+        return PricingHelpers_1.default.getVariantPricing(variant, {
+            isTaxable: this.attributes.isTaxable,
+            taxCategory: this.attributes.taxCategory,
+        }, { countryCode });
+    }
+    // SKU and variant-description accessors. Centralize the parent-SKU
+    // fallback and the human-readable options join so every label printer,
+    // receipt builder, and admin list view that surfaces a variant uses
+    // the same rule. Returns '' for missing SKUs / variants rather than
+    // throwing — callers were doing their own fallback anyway.
+    getEffectiveSku() {
+        return String(this.attributes.sku || '').trim();
+    }
+    getEffectiveVariantSku(variantId) {
+        const variants = (this.attributes.variantInventory || []);
+        const variant = variants.find((v) => v && v.id === variantId) || null;
+        return ProductSkuHelpers_1.default.effectiveVariantSku({ sku: this.attributes.sku }, variant);
+    }
+    describeVariant(variantId) {
+        const variants = (this.attributes.variantInventory || []);
+        const variant = variants.find((v) => v && v.id === variantId);
+        if (!variant)
+            return '';
+        return ProductSkuHelpers_1.default.describeVariantOptions(variant.options || {});
+    }
+    // Diagnose whether a variant-inventory product is purchasable. Mirrors
+    // the readiness gate the retail entry exposes as a confirm-before-save
+    // dialog: a multivariant product with no variants generated yet, or
+    // with every variant carrying zero across all locations, is technically
+    // savable but customers won't be able to buy anything from it. Returns
+    // 'ok' for non-multivariant products (single-row / unique inventory
+    // are handled by other checks).
+    diagnoseVariantInventory() {
+        const variants = (this.attributes.variantInventory || []);
+        if (this.attributes.productClass !== 'MULTIVARIANT')
+            return 'ok';
+        if (!variants.length)
+            return 'no_variants';
+        const allZero = variants.every((v) => {
+            const locs = Array.isArray(v === null || v === void 0 ? void 0 : v.locations) ? v.locations : [];
+            const total = locs.reduce((acc, loc) => acc + (Number(loc === null || loc === void 0 ? void 0 : loc.availableAmount) || 0), 0);
+            return total <= 0;
+        });
+        return allZero ? 'all_zero_qty' : 'ok';
+    }
     toProductInputObjForShopify(location) {
         const productInputObj = {
             title: this.attributes.title,
@@ -505,6 +616,7 @@ class Product extends Base_1.default {
         const createdAtTimestamp = this.utilities.sanitizeMillisTimeStamp(this.timestampAttributes.createdAtTimestamp);
         const { createdAtHour, createdAtDay, createdAtMonth, createdAtYear } = this.utilities.formatTimestamp(createdAtTimestamp);
         const [priceSold, commissionFee, productionFee, fulfillmentFee] = ReRobeProductHelpers_1.default.buildReRobeEarningsV2(this.toObj(), isCanonicalMerchant);
+        const marketplaceFields = MarketplaceProductHelpers_1.default.buildTypesenseFields(this.attributes.marketplace);
         const merchantValue = commissionFee + productionFee + fulfillmentFee;
         const sellerValue = priceSold - merchantValue;
         const calculatedCommission = merchantValue / priceSold;
@@ -523,6 +635,10 @@ class Product extends Base_1.default {
             isTaxable: this.utilities.sanitizeString(this.attributes.isTaxable),
             merchants: this.utilities.sanitzeStringArr(this.attributes.merchants),
             merchantId: this.utilities.sanitizeString(this.attributes.merchantId),
+            marketplaceVisibleToMerchantIds: marketplaceFields.marketplaceVisibleToMerchantIds,
+            marketplaceParentMerchantIds: marketplaceFields.marketplaceParentMerchantIds,
+            marketplaceRelationshipIds: marketplaceFields.marketplaceRelationshipIds,
+            isMarketplaceVisible: marketplaceFields.isMarketplaceVisible,
             price: this.utilities.sanitizeNumber(this.attributes.price),
             merchantValue: this.utilities.sanitizeNumber(merchantValue),
             sellerValue: this.utilities.sanitizeNumber(sellerValue),
@@ -979,6 +1095,30 @@ class Product extends Base_1.default {
                     name: 'merchants',
                     type: 'string[]',
                 },
+                {
+                    facet: false,
+                    optional: true,
+                    name: 'marketplaceVisibleToMerchantIds',
+                    type: 'string[]',
+                },
+                {
+                    facet: false,
+                    optional: true,
+                    name: 'marketplaceParentMerchantIds',
+                    type: 'string[]',
+                },
+                {
+                    facet: false,
+                    optional: true,
+                    name: 'marketplaceRelationshipIds',
+                    type: 'string[]',
+                },
+                {
+                    facet: true,
+                    optional: true,
+                    name: 'isMarketplaceVisible',
+                    type: 'bool',
+                },
                 {
                     facet: false,
                     optional: true,

package/lib/types/pricing-types.d.ts

@@ -0,0 +1,85 @@
+import { TaxCategoryValue } from '../constants/tax-constants';
+export type IsTaxableValue = 'yes' | 'no' | boolean | string | undefined | null;
+export interface CatalogRateInput {
+    countryCode: string;
+    taxCategory: string | null | undefined;
+    isTaxable: IsTaxableValue;
+}
+export interface FrozenRateInput {
+    taxRate: number | string | null | undefined;
+    isTaxable: IsTaxableValue;
+}
+export type RateInput = CatalogRateInput | FrozenRateInput;
+export interface TaxResolution {
+    rate: number;
+    category?: TaxCategoryValue;
+    taxable: boolean;
+}
+export interface ProductPricing {
+    rate: number;
+    taxable: boolean;
+    priceNet: string;
+    salePriceNet: string;
+    compareAtPriceNet: string;
+    costPerItemNet: string;
+    priceGross: string;
+    salePriceGross: string;
+    compareAtPriceGross: string;
+    costPerItemGross: string;
+}
+export interface VariantPricing {
+    rate: number;
+    taxable: boolean;
+    priceNet: string;
+    salePriceNet: string;
+    compareAtPriceNet: string;
+    costPerItemNet: string;
+    priceGross: string;
+    salePriceGross: string;
+    compareAtPriceGross: string;
+    costPerItemGross: string;
+}
+export interface OrderLinePricing {
+    rate: number;
+    taxable: boolean;
+    unitPriceNet: string;
+    unitPriceGross: string;
+    totalPriceNet: string;
+    totalPriceGross: string;
+    salePriceNet: string;
+    salePriceGross: string;
+}
+export interface ProductPricingLike {
+    isTaxable?: IsTaxableValue;
+    taxCategory?: string | null;
+    price?: string | number | null;
+    salePrice?: string | number | null;
+    compareAtPrice?: string | number | null;
+    costPerItem?: string | number | null;
+}
+export interface VariantPricingLike {
+    taxable?: IsTaxableValue;
+    price?: string | number | null;
+    salePrice?: string | number | null;
+    compareAtPrice?: string | number | null;
+    costPerItem?: string | number | null;
+}
+export interface OrderLinePricingLike {
+    isTaxable?: IsTaxableValue;
+    taxRate?: number | string | null;
+    originalUnitPrice?: {
+        amount?: number | string | null;
+    } | null;
+    originalTotalPrice?: {
+        amount?: number | string | null;
+    } | null;
+    salePrice?: {
+        amount?: number | string | null;
+    } | number | string | null;
+}
+export interface TaxCategoryOption {
+    value: string;
+    label: string;
+    rate: number;
+    rateLabel: string;
+}

package/lib/types/pricing-types.js

@@ -0,0 +1,5 @@
+"use strict";
+// Shared pricing types. Cross-cutting between Product (catalog) and Order
+// (frozen-rate) surfaces, kept dependency-free so they can be consumed by
+// helpers, models, and form-states without circular imports.
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/rerobe-order-types.d.ts

@@ -351,7 +351,93 @@ interface ReRobeOrderLineItem extends OrderLineItem {
     discountedPrice?: Money;
     taxAmountWithDiscount?: Money;
     handle?: string;
+    marketplace?: MarketplaceLineSnapshot;
 }
+type MarketplaceCommissionBasis = 'LINE_NET_EXCLUDING_TAX' | 'ORIGINAL_COMMISSION_SHARE' | string;
+type MarketplaceLineAmounts = {
+    lineNetAmount: number;
+    discountAmount: number;
+    taxableAmount: number;
+    taxAmount: number;
+    lineGrossAmount: number;
+    originalProductCommissionAmount: number;
+    marketplaceCommissionAmount: number;
+    stripeFeeAllocatedAmount: number;
+    ribbnFeeAllocatedAmount: number;
+    sellerProceedsAmount: number;
+    managedMerchantProceedsAmount: number;
+    marketplaceProceedsAmount: number;
+};
+type MarketplaceVariantSnapshot = {
+    variantId: string;
+    sku: string;
+    options: VariantOptions;
+    price: string;
+    compareAtPrice?: string | null;
+    salePrice?: string | null;
+    isOnSale?: 'yes' | 'no' | null;
+    taxable?: 'yes' | 'no' | null;
+    taxCategory: string;
+    locations: InventoryLocation[];
+};
+type MarketplaceLineSnapshot = {
+    isMarketplaceItem: boolean;
+    parentMerchantId: string;
+    managedMerchantId: string;
+    relationshipId: string;
+    productId: string;
+    variantId?: string;
+    sellerDisplayName?: string;
+    lineDisplayTitle?: string;
+    originalProductCommissionRate: string;
+    marketplaceCommissionRate: string;
+    marketplaceCommissionBasis: MarketplaceCommissionBasis;
+    quantity: number;
+    currencyCode: string;
+    amounts: MarketplaceLineAmounts;
+    variant?: MarketplaceVariantSnapshot;
+};
+type MarketplaceReturnAdjustment = {
+    quantityReturned: number;
+    amounts: MarketplaceLineAmounts;
+    remainingQuantity: number;
+};
+type MarketplaceLedgerStatus = 'PENDING_RETURN_PERIOD' | 'PAYABLE' | 'PAID_OUT' | 'RETURNED_BEFORE_PAYOUT' | 'REFUNDED_AFTER_PAYOUT' | 'TRANSFER_REVERSED' | string;
+type MarketplaceLedgerLifecycleTimestamps = {
+    createdAtTimestamp?: number | null;
+    pendingReturnPeriodAtTimestamp?: number | null;
+    payableAtTimestamp?: number | null;
+    paidOutAtTimestamp?: number | null;
+    returnedBeforePayoutAtTimestamp?: number | null;
+    refundedAfterPayoutAtTimestamp?: number | null;
+    transferReversedAtTimestamp?: number | null;
+    updatedAtTimestamp?: number | null;
+};
+type MarketplaceLedgerEntry = {
+    documentId?: string;
+    parentOrderId: string;
+    parentOrderLineItemId?: string;
+    parentMerchantId: string;
+    managedMerchantId: string;
+    relationshipId: string;
+    productId: string;
+    variantId?: string;
+    status: MarketplaceLedgerStatus;
+    snapshot: MarketplaceLineSnapshot;
+    returnDeadlineTimestamp?: number | null;
+    lifecycle: MarketplaceLedgerLifecycleTimestamps;
+};
+type MarketplaceFeeAllocation = {
+    lineKey: string;
+    amount: number;
+};
+type MarketplaceFeeBasketLine = {
+    lineKey: string;
+    sellerMerchantId: string;
+    lineNetAmount: number;
+    taxableAmount?: number;
+    quantity?: number;
+};
 type OrderLineItemConnection = {
     edges: OrderLineItemEdge[];
 };

package/lib/types/rerobe-product-types.d.ts

@@ -34,6 +34,7 @@ type ProductAttributes = {
     taxCategory?: string;
     productClass?: 'UNIQUE' | 'MULTIVARIANT' | 'TEMPLATE' | 'SUPPLY' | 'DIGITAL' | string;
     variantInventory?: VariantInventory[];
+    marketplace?: ProductMarketplace;
 };
 type ProductFilterAttributes = {
     documentId: string;
@@ -173,6 +174,20 @@ type VariantInventory = {
     costPerItem?: string | null;
     continueSellingWhenOutOfStock?: boolean | null;
 };
+type MarketplaceListingStatus = 'ACTIVE' | 'PAUSED' | 'REMOVED' | string;
+type ProductMarketplaceListing = {
+    relationshipId: string;
+    relationshipType: string;
+    status: MarketplaceListingStatus;
+    listedAt?: number | null;
+    updatedAt?: number | null;
+};
+type ProductMarketplace = {
+    visibleToMerchantIds: string[];
+    listings: {
+        [parentMarketplaceId: string]: ProductMarketplaceListing;
+    };
+};
 type ProductSellStatusKeys = 'SELL_REQUEST_REVIEW' | 'REJECTED' | 'HOLD' | 'ACCEPTED' | 'DROP_OFF_AT_REROBE' | 'SHIP_TO_REROBE' | 'AT_HOME_PICK_UP' | 'QUALITY_CONTROL' | 'LISTED' | 'SOLD' | 'RETURNED' | 'SOLD_SELLER_TO_BE_PAID' | 'SOLD_SELLER_PAID' | 'HIDDEN' | 'BOOKED' | 'OPEN';
 type ProductPublishKeys = 'USER_PUBLISHED' | 'MERCHANT_PUBLISHED';
 type ShopifyProduct = ProductAttributes & ProductFilterAttributes;
@@ -329,6 +344,10 @@ type TypesenseProductObj = {
     sku: string;
     salesChannel: string[];
     thirdPartySalesChannels: string[];
+    marketplaceVisibleToMerchantIds: string[];
+    marketplaceParentMerchantIds: string[];
+    marketplaceRelationshipIds: string[];
+    isMarketplaceVisible: boolean;
     status: string;
     tags: string[];
     systemTags: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rerobe-js-orm",
-  "version": "4.8.8",
+  "version": "4.9.0",
   "description": "ReRobe's Javascript ORM Framework",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",