@hexclave/shared 1.0.2 → 1.0.5

package/src/config/migrate-catalogs-to-product-lines.ts

@@ -0,0 +1,475 @@
+import { HexclaveAssertionError } from "../utils/errors";
+import { isObjectLike, set, typedEntries } from "../utils/objects";
+
+/**
+ * Renames properties in an object based on a path condition.
+ * This is a local copy to avoid circular dependencies with schema.ts.
+ */
+function renameProperty(obj: Record<string, any>, oldPath: string | ((path: string[]) => boolean), newName: string | ((path: string[]) => string)): any {
+  const pathCond = typeof oldPath === "function" ? oldPath : (p: string[]) => p.join(".") === oldPath;
+  const pathMapper = typeof newName === "function" ? newName : (p: string[]) => (newName as string);
+
+  const res: Record<string, any> = Array.isArray(obj) ? [] : {};
+  for (const [key, originalValue] of typedEntries(obj)) {
+    const path = key.split(".");
+
+    for (let i = 0; i < path.length; i++) {
+      const pathPrefix = path.slice(0, i + 1);
+      if (pathCond(pathPrefix)) {
+        const name = pathMapper(pathPrefix);
+        if (name.includes(".")) throw new HexclaveAssertionError(`newName must not contain a dot. Provided: ${name}`);
+        path[i] = name;
+      }
+    }
+
+    const value = isObjectLike(originalValue) ? renameProperty(originalValue, p => pathCond([...path, ...p]), p => pathMapper([...path, ...p])) : originalValue;
+    set(res, path.join("."), value);
+  }
+
+  return res;
+}
+
+/**
+ * Migrates the old "catalogs" format to "productLines", including:
+ * 1. Inferring customerType for each catalog from its products (since old catalogs didn't have customerType)
+ * 2. Removing empty catalogs (those with no products) since they can't have customerType inferred
+ * 3. Renaming payments.catalogs -> payments.productLines
+ * 4. Renaming payments.products.*.catalogId -> payments.products.*.productLineId
+ *
+ * This handles all config formats (nested objects, flat dot-notation, or mixed).
+ */
+export function migrateCatalogsToProductLines(obj: Record<string, any>): Record<string, any> {
+  // Step 1: Collect catalogId -> customerType mappings from products
+  const catalogCustomerTypes = new Map<string, string>();
+  collectCatalogCustomerTypes(obj, [], catalogCustomerTypes);
+
+  // Step 2: Find all catalog IDs that exist
+  const allCatalogIds = new Set<string>();
+  findAllCatalogIds(obj, [], allCatalogIds);
+
+  // Step 3: Add customerType keys for catalogs that need them
+  let res = { ...obj };
+  for (const catalogId of allCatalogIds) {
+    const customerType = catalogCustomerTypes.get(catalogId);
+    if (customerType) {
+      // Find the format used for this catalog and add customerType in the same format
+      res = addCustomerTypeToCatalog(res, catalogId, customerType);
+    } else {
+      // Empty catalog (no products) - remove it since we can't infer customerType
+      res = removeCatalog(res, catalogId);
+    }
+  }
+
+  // Step 4: Rename catalogs -> productLines
+  res = renameProperty(res, "payments.catalogs", "productLines");
+
+  // Step 5: Rename catalogId -> productLineId in products
+  res = renameProperty(res, (p) => p.length === 4 && p[0] === "payments" && p[1] === "products" && p[3] === "catalogId", () => "productLineId");
+
+  return res;
+}
+
+/**
+ * Recursively collects catalogId -> customerType mappings from products.
+ * Handles both nested and flat config formats.
+ */
+function collectCatalogCustomerTypes(
+  obj: Record<string, any>,
+  basePath: string[],
+  result: Map<string, string>
+): void {
+  for (const [key, value] of typedEntries(obj)) {
+    const keyParts = key.split(".");
+    const fullPath = [...basePath, ...keyParts];
+
+    // Check for flat format at ROOT level only: payments.products.<productId>.catalogId
+    // We check basePath.length === 0 to ensure we're at root and key contains the full path
+    if (basePath.length === 0 && fullPath.length === 4 && fullPath[0] === "payments" && fullPath[1] === "products" && fullPath[3] === "catalogId") {
+      if (typeof value === "string") {
+        const productId = fullPath[2];
+        // Look for customerType in the same flat format
+        const customerTypeKey = `payments.products.${productId}.customerType`;
+        if (customerTypeKey in obj && typeof obj[customerTypeKey] === "string") {
+          result.set(value, obj[customerTypeKey]);
+        }
+      }
+    }
+
+    // Check for nested format: payments.products.<productId> with object value
+    if (fullPath.length === 3 && fullPath[0] === "payments" && fullPath[1] === "products" && isObjectLike(value)) {
+      const catalogId = findPropertyValue(value, "catalogId") ?? findPropertyValue(value, "productLineId");
+      const customerType = findPropertyValue(value, "customerType");
+      if (catalogId && typeof catalogId === "string" && customerType && typeof customerType === "string") {
+        result.set(catalogId, customerType);
+      }
+    }
+
+    if (isObjectLike(value)) {
+      collectCatalogCustomerTypes(value, fullPath, result);
+    }
+  }
+}
+
+/**
+ * Finds a property value in an object, handling both direct properties and dot-notation keys.
+ */
+function findPropertyValue(obj: Record<string, any>, propertyName: string): any {
+  // Direct property
+  if (propertyName in obj) {
+    return obj[propertyName];
+  }
+  // Check for dot-notation keys that end with the property name
+  for (const key of Object.keys(obj)) {
+    const parts = key.split(".");
+    if (parts[parts.length - 1] === propertyName) {
+      return obj[key];
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Finds all catalog IDs that exist in the config.
+ */
+function findAllCatalogIds(
+  obj: Record<string, any>,
+  basePath: string[],
+  result: Set<string>
+): void {
+  for (const [key, value] of typedEntries(obj)) {
+    const keyParts = key.split(".");
+    const fullPath = [...basePath, ...keyParts];
+
+    // Check for catalog entry at payments.catalogs.<catalogId>
+    if (fullPath.length >= 3 && fullPath[0] === "payments" && fullPath[1] === "catalogs") {
+      const catalogId = fullPath[2];
+      result.add(catalogId);
+    }
+
+    if (isObjectLike(value)) {
+      findAllCatalogIds(value, fullPath, result);
+    }
+  }
+}
+
+/**
+ * Removes a catalog from the config in any format (nested or flat).
+ */
+function removeCatalog(obj: Record<string, any>, catalogId: string): Record<string, any> {
+  // Don't process arrays - they should be copied as-is
+  if (Array.isArray(obj)) {
+    return obj;
+  }
+
+  const res: Record<string, any> = {};
+
+  for (const [key, value] of typedEntries(obj)) {
+    const keyParts = key.split(".");
+
+    // Check if this key is for the catalog we want to remove
+    // Format 4: "payments.catalogs.<catalogId>.displayName" or similar flat keys
+    if (keyParts.length >= 3 && keyParts[0] === "payments" && keyParts[1] === "catalogs" && keyParts[2] === catalogId) {
+      // Skip this key - don't copy it
+      continue;
+    }
+
+    // Format 3: "payments.catalogs.<catalogId>" as a single key
+    if (key === `payments.catalogs.${catalogId}`) {
+      continue;
+    }
+
+    if (Array.isArray(value)) {
+      res[key] = value;
+    } else if (isObjectLike(value)) {
+      const processed = removeCatalog(value, catalogId);
+      // Check if we need to remove the catalog from nested structures
+      if (key === "payments" && isObjectLike(processed) && "catalogs" in processed) {
+        const catalogs = processed.catalogs;
+        if (isObjectLike(catalogs) && catalogId in catalogs) {
+          const { [catalogId]: _, ...rest } = catalogs as Record<string, any>;
+          res[key] = { ...processed, catalogs: rest };
+          continue;
+        }
+      }
+      // Format 2: "payments.catalogs" as a key with nested catalog
+      if (key === "payments.catalogs" && isObjectLike(processed) && catalogId in processed) {
+        const { [catalogId]: _, ...rest } = processed as Record<string, any>;
+        res[key] = rest;
+        continue;
+      }
+      res[key] = processed;
+    } else {
+      res[key] = value;
+    }
+  }
+
+  return res;
+}
+
+/**
+ * Adds customerType to a catalog in the appropriate format.
+ */
+function addCustomerTypeToCatalog(obj: Record<string, any>, catalogId: string, customerType: string): Record<string, any> {
+  // Don't process arrays - they should be copied as-is
+  if (Array.isArray(obj)) {
+    return obj;
+  }
+
+  const res: Record<string, any> = {};
+
+  // First, copy all existing properties
+  for (const [key, value] of typedEntries(obj)) {
+    if (Array.isArray(value)) {
+      // Copy arrays directly without processing
+      res[key] = value;
+    } else if (isObjectLike(value)) {
+      res[key] = addCustomerTypeToCatalog(value, catalogId, customerType);
+    } else {
+      res[key] = value;
+    }
+  }
+
+  // Check what format the catalog uses
+  // Format 1: { payments: { catalogs: { [catalogId]: { ... } } } }
+  const payments = res.payments;
+  if (payments && isObjectLike(payments) && !Array.isArray(payments) && typeof payments !== "function") {
+    const paymentsObj = payments as Record<string, any>;
+    const catalogs = paymentsObj.catalogs;
+    if (catalogs && isObjectLike(catalogs) && !Array.isArray(catalogs) && typeof catalogs !== "function") {
+      const catalogsObj = catalogs as Record<string, any>;
+      const catalog = catalogsObj[catalogId];
+      if (catalog && isObjectLike(catalog)) {
+        if (!("customerType" in catalog)) {
+          catalogsObj[catalogId] = { ...catalog, customerType };
+        }
+        return res;
+      }
+    }
+  }
+
+  // Format 2: { "payments.catalogs": { [catalogId]: { ... } } }
+  const paymentsCatalogs = res["payments.catalogs"];
+  if (paymentsCatalogs && isObjectLike(paymentsCatalogs) && !Array.isArray(paymentsCatalogs) && typeof paymentsCatalogs !== "function") {
+    const catalogs = paymentsCatalogs as Record<string, any>;
+    if (catalogId in catalogs && isObjectLike(catalogs[catalogId])) {
+      if (!("customerType" in catalogs[catalogId])) {
+        catalogs[catalogId] = { ...catalogs[catalogId], customerType };
+      }
+      return res;
+    }
+  }
+
+  // Format 3: { "payments.catalogs.[catalogId]": { ... } }
+  const catalogKey = `payments.catalogs.${catalogId}`;
+  if (catalogKey in res && isObjectLike(res[catalogKey])) {
+    if (!("customerType" in res[catalogKey])) {
+      res[catalogKey] = { ...res[catalogKey], customerType };
+    }
+    return res;
+  }
+
+  // Format 4: { "payments.catalogs.[catalogId].displayName": "..." }
+  // Need to add a new key for customerType
+  const customerTypeKey = `payments.catalogs.${catalogId}.customerType`;
+  for (const key of Object.keys(res)) {
+    if (key.startsWith(`payments.catalogs.${catalogId}.`) && key !== customerTypeKey) {
+      // Found a flat key for this catalog, add customerType in same format
+      res[customerTypeKey] = customerType;
+      return res;
+    }
+  }
+
+  return res;
+}
+
+// Tests
+import.meta.vitest?.test("migrateCatalogsToProductLines - basic migrations", ({ expect }) => {
+  // Basic nested format
+  expect(migrateCatalogsToProductLines({
+    payments: {
+      catalogs: {
+        myCatalog: { displayName: "My Catalog" }
+      },
+      products: {
+        myProduct: { catalogId: "myCatalog", customerType: "user", prices: {} }
+      }
+    }
+  })).toEqual({
+    payments: {
+      productLines: {
+        myCatalog: { displayName: "My Catalog", customerType: "user" }
+      },
+      products: {
+        myProduct: { productLineId: "myCatalog", customerType: "user", prices: {} }
+      }
+    }
+  });
+
+  // Flat format
+  expect(migrateCatalogsToProductLines({
+    "payments.catalogs.myCatalog": { displayName: "My Catalog" },
+    "payments.products.myProduct.catalogId": "myCatalog",
+    "payments.products.myProduct.customerType": "user",
+  })).toEqual({
+    "payments.productLines.myCatalog": { displayName: "My Catalog", customerType: "user" },
+    "payments.products.myProduct.productLineId": "myCatalog",
+    "payments.products.myProduct.customerType": "user",
+  });
+
+  // Mixed format
+  expect(migrateCatalogsToProductLines({
+    payments: {
+      catalogs: { myCatalog: { displayName: "My Catalog" } }
+    },
+    "payments.products.myProduct": { catalogId: "myCatalog", customerType: "user" }
+  })).toEqual({
+    payments: {
+      productLines: { myCatalog: { displayName: "My Catalog", customerType: "user" } }
+    },
+    "payments.products.myProduct": { productLineId: "myCatalog", customerType: "user" }
+  });
+});
+
+import.meta.vitest?.test("migrateCatalogsToProductLines - does not overwrite existing customerType", ({ expect }) => {
+  // If catalog already has customerType, don't overwrite it
+  expect(migrateCatalogsToProductLines({
+    payments: {
+      catalogs: {
+        myCatalog: { displayName: "My Catalog", customerType: "team" }
+      },
+      products: {
+        myProduct: { catalogId: "myCatalog", customerType: "user", prices: {} }
+      }
+    }
+  })).toEqual({
+    payments: {
+      productLines: {
+        myCatalog: { displayName: "My Catalog", customerType: "team" }
+      },
+      products: {
+        myProduct: { productLineId: "myCatalog", customerType: "user", prices: {} }
+      }
+    }
+  });
+});
+
+import.meta.vitest?.test("migrateCatalogsToProductLines - multiple catalogs and products", ({ expect }) => {
+  expect(migrateCatalogsToProductLines({
+    payments: {
+      catalogs: {
+        userPlans: { displayName: "User Plans" },
+        teamPlans: { displayName: "Team Plans" }
+      },
+      products: {
+        userBasic: { catalogId: "userPlans", customerType: "user", prices: {} },
+        userPro: { catalogId: "userPlans", customerType: "user", prices: {} },
+        teamBasic: { catalogId: "teamPlans", customerType: "team", prices: {} }
+      }
+    }
+  })).toEqual({
+    payments: {
+      productLines: {
+        userPlans: { displayName: "User Plans", customerType: "user" },
+        teamPlans: { displayName: "Team Plans", customerType: "team" }
+      },
+      products: {
+        userBasic: { productLineId: "userPlans", customerType: "user", prices: {} },
+        userPro: { productLineId: "userPlans", customerType: "user", prices: {} },
+        teamBasic: { productLineId: "teamPlans", customerType: "team", prices: {} }
+      }
+    }
+  });
+});
+
+import.meta.vitest?.test("migrateCatalogsToProductLines - catalog without products is removed", ({ expect }) => {
+  // Catalog without any products should be removed since we can't infer customerType
+  expect(migrateCatalogsToProductLines({
+    payments: {
+      catalogs: {
+        emptyCatalog: { displayName: "Empty" }
+      },
+      products: {}
+    }
+  })).toEqual({
+    payments: {
+      productLines: {},
+      products: {}
+    }
+  });
+});
+
+import.meta.vitest?.test("migrateCatalogsToProductLines - products without catalogId", ({ expect }) => {
+  // Catalogs without any products referencing them should be removed
+  expect(migrateCatalogsToProductLines({
+    payments: {
+      catalogs: {
+        myCatalog: { displayName: "My Catalog" }
+      },
+      products: {
+        standalone: { customerType: "user", prices: {} }
+      }
+    }
+  })).toEqual({
+    payments: {
+      productLines: {},
+      products: {
+        standalone: { customerType: "user", prices: {} }
+      }
+    }
+  });
+});
+
+import.meta.vitest?.test("migrateCatalogsToProductLines - deeply nested flat format", ({ expect }) => {
+  expect(migrateCatalogsToProductLines({
+    "payments.catalogs.myCatalog.displayName": "My Catalog",
+    "payments.products.myProduct.catalogId": "myCatalog",
+    "payments.products.myProduct.customerType": "user",
+    "payments.products.myProduct.prices": {},
+  })).toEqual({
+    "payments.productLines.myCatalog.displayName": "My Catalog",
+    "payments.productLines.myCatalog.customerType": "user",
+    "payments.products.myProduct.productLineId": "myCatalog",
+    "payments.products.myProduct.customerType": "user",
+    "payments.products.myProduct.prices": {},
+  });
+});
+
+import.meta.vitest?.test("migrateCatalogsToProductLines - no catalogs", ({ expect }) => {
+  // Config without catalogs should pass through unchanged (except productLineId rename)
+  expect(migrateCatalogsToProductLines({
+    payments: {
+      products: {
+        myProduct: { catalogId: "someCatalog", customerType: "user" }
+      }
+    }
+  })).toEqual({
+    payments: {
+      products: {
+        myProduct: { productLineId: "someCatalog", customerType: "user" }
+      }
+    }
+  });
+});
+
+import.meta.vitest?.test("migrateCatalogsToProductLines - already migrated (productLines)", ({ expect }) => {
+  // Already has productLines, should not change customerType
+  expect(migrateCatalogsToProductLines({
+    payments: {
+      productLines: {
+        myLine: { displayName: "My Line", customerType: "team" }
+      },
+      products: {
+        myProduct: { productLineId: "myLine", customerType: "team" }
+      }
+    }
+  })).toEqual({
+    payments: {
+      productLines: {
+        myLine: { displayName: "My Line", customerType: "team" }
+      },
+      products: {
+        myProduct: { productLineId: "myLine", customerType: "team" }
+      }
+    }
+  });
+});