326 lines
13 KiB
TypeScript
326 lines
13 KiB
TypeScript
import type { Printful, Webflow } from "./util/types";
|
|
import { formatSlug, type DeepPartial } from "./util/misc";
|
|
import { WebflowClient } from "./webflow";
|
|
import { PrintfulClient } from "./printful";
|
|
import pino from "pino";
|
|
|
|
const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
|
|
|
|
type ProductEntry = {
|
|
colorGroup: string | null;
|
|
product: Printful.Products.Product;
|
|
};
|
|
|
|
type PMetaProduct = {
|
|
name: string;
|
|
wProductId: string;
|
|
entries: ProductEntry[];
|
|
};
|
|
|
|
export type ProductSyncerOptions = {
|
|
filter?: {
|
|
pProductIds?: number[];
|
|
},
|
|
beforeStart?: (startDate: Date) => Promise<void>
|
|
afterCompletion?: (completionDate: Date, duration: number) => Promise<void>
|
|
beforeStep?: (pProductIds: number[]) => Promise<void>
|
|
};
|
|
|
|
export class ProductSyncer {
|
|
private log: pino.Logger;
|
|
|
|
constructor(
|
|
private Printful: PrintfulClient,
|
|
private Webflow: WebflowClient,
|
|
log?: pino.Logger,
|
|
) {
|
|
this.log = (log ?? pino({ level: "silent" })).child({ component: "ProductSyncer" });
|
|
}
|
|
|
|
async syncApparel(opt: ProductSyncerOptions = {}) {
|
|
const startDate = new Date();
|
|
await opt.beforeStart?.(startDate);
|
|
|
|
if (opt.filter?.pProductIds)
|
|
this.log.info({ pProductIds: opt.filter.pProductIds }, "apparel sync started (filtered)");
|
|
else
|
|
this.log.info("apparel sync started (all)");
|
|
|
|
this.log.debug("retrieving webflow products");
|
|
const allWProducts = await this.Webflow.Products.list({ forceAll: true });
|
|
|
|
this.log.debug("retrieving printful products");
|
|
const allPProducts = await this.Printful.Products.list({ forceAll: true });
|
|
|
|
this.log.info({ pProductCount: allPProducts.length, filter: opt.filter ?? "N/A" }, "generating printful meta products");
|
|
const pMetaProducts = await this.generatePMetaProducts(allWProducts, allPProducts, opt);
|
|
|
|
for (const pMetaProduct of pMetaProducts) {
|
|
const pProductIds = pMetaProduct.entries.map((e) => e.product.sync_product.id);
|
|
this.log.info({ name: pMetaProduct.name, externalId: pMetaProduct.wProductId, pProductIds }, "syncing printful meta product");
|
|
await opt.beforeStep?.(pProductIds);
|
|
|
|
const newWSkus: DeepPartial<Webflow.Products.Skus.Sku>[] = this.generateWSkus(pMetaProduct);
|
|
const foundColors = new Set<string>(
|
|
newWSkus.map((sku) => sku.fieldData?.["sku-values"]?.["color"]).filter((v) => v !== undefined)
|
|
);
|
|
const foundSizes = new Set<string>(
|
|
newWSkus.map((sku) => sku.fieldData?.["sku-values"]?.["size"]).filter((v) => v !== undefined)
|
|
);
|
|
|
|
if (!newWSkus[0]) throw new Error("no webflow SKUs generated — all variants were filtered out");
|
|
|
|
const wProductFieldData = {
|
|
name: pMetaProduct.name,
|
|
slug: formatSlug(pMetaProduct.name),
|
|
shippable: true,
|
|
"tax-category": "standard-taxable",
|
|
"sku-properties": [
|
|
{
|
|
id: "color",
|
|
name: "Color",
|
|
enum: Array.from(foundColors).map((color) => ({
|
|
id: color,
|
|
slug: formatSlug(color),
|
|
name: color,
|
|
})),
|
|
},
|
|
{
|
|
id: "size",
|
|
name: "Size",
|
|
enum: Array.from(foundSizes).map((size) => ({
|
|
id: size,
|
|
slug: formatSlug(size),
|
|
name: size,
|
|
})),
|
|
},
|
|
],
|
|
};
|
|
|
|
const wProduct = allWProducts.find((wp) => wp.product.id === pMetaProduct.wProductId);
|
|
|
|
if (wProduct) {
|
|
this.log.info({ id: wProduct.product.id }, "existing webflow product found, updating it");
|
|
|
|
// do not update images
|
|
for (const sku of newWSkus) delete sku.fieldData?.["main-image"];
|
|
|
|
// handle case where webflow SKU created by associated printful variant external_id update failed
|
|
if (!newWSkus[0].id) {
|
|
this.log.warn({ wSku: newWSkus[0] }, "missing webflow SKU id");
|
|
const wSkuMatch = this.resolveWSku(
|
|
wProduct.skus,
|
|
newWSkus[0].fieldData?.["sku-values"]?.["color"],
|
|
newWSkus[0].fieldData?.["sku-values"]?.["size"],
|
|
);
|
|
|
|
if (wSkuMatch)
|
|
newWSkus[0].id = wSkuMatch.id;
|
|
else
|
|
this.log.warn({ wSku: newWSkus[0] }, "could not find existing webflow SKU that matches");
|
|
}
|
|
|
|
await this.Webflow.Products.update(wProduct.product.id, {
|
|
product: { fieldData: wProductFieldData },
|
|
sku: newWSkus[0],
|
|
});
|
|
|
|
for (const newWSku of newWSkus) {
|
|
const existingWSku = this.resolveWSku(
|
|
wProduct.skus,
|
|
newWSku.fieldData?.["sku-values"]?.["color"],
|
|
newWSku.fieldData?.["sku-values"]?.["size"],
|
|
newWSku.id,
|
|
);
|
|
if (existingWSku) {
|
|
await this.Webflow.Products.Skus.update(
|
|
pMetaProduct.wProductId,
|
|
existingWSku.id,
|
|
newWSku,
|
|
);
|
|
} else {
|
|
await this.Webflow.Products.Skus.create(
|
|
pMetaProduct.wProductId,
|
|
[newWSku],
|
|
);
|
|
}
|
|
}
|
|
} else {
|
|
this.log.info("existing webflow product not found, creating it");
|
|
|
|
const wProductId = await this.Webflow.Products.create({
|
|
product: { fieldData: wProductFieldData },
|
|
sku: newWSkus[0],
|
|
});
|
|
pMetaProduct.wProductId = wProductId;
|
|
|
|
if (newWSkus.length > 1)
|
|
await this.Webflow.Products.Skus.create(wProductId, newWSkus.slice(1));
|
|
}
|
|
|
|
// Re-fetch after SKU mutations so newly created SKUs have their real IDs.
|
|
const freshWProduct = await this.Webflow.Products.get(pMetaProduct.wProductId);
|
|
if (!freshWProduct) throw new Error("webflow product missing");
|
|
|
|
// Update printful external IDs
|
|
for (const { colorGroup, product: pProduct } of pMetaProduct.entries) {
|
|
const expectedExternalId = colorGroup ?
|
|
`${pMetaProduct.wProductId}-${colorGroup}` :
|
|
pMetaProduct.wProductId;
|
|
if (pProduct.sync_product.external_id === expectedExternalId) continue;
|
|
|
|
const pVariantPatches: DeepPartial<Printful.Products.SyncVariant>[] = [];
|
|
for (const pVariant of pProduct.sync_variants) {
|
|
const wSku = this.resolveWSku(
|
|
freshWProduct.skus,
|
|
colorGroup ?? pVariant.color,
|
|
pVariant.size,
|
|
);
|
|
if (wSku) {
|
|
pVariantPatches.push({
|
|
id: pVariant.id,
|
|
external_id: String(wSku.id),
|
|
});
|
|
}
|
|
}
|
|
|
|
await sleep(10000);
|
|
this.log.info({ pProduct: pProduct.sync_product.id, externalId: expectedExternalId }, "updating printful product's external ID");
|
|
await this.Printful.Products.update(pProduct.sync_product.id, {
|
|
sync_product: {
|
|
id: pProduct.sync_product.id,
|
|
external_id: expectedExternalId,
|
|
},
|
|
sync_variants: pVariantPatches,
|
|
});
|
|
}
|
|
}
|
|
|
|
const endDate = new Date();
|
|
const duration = endDate.getTime() - startDate.getTime();
|
|
await opt.afterCompletion?.(endDate, duration);
|
|
this.log.info({ durationMs: duration }, "sync complete");
|
|
}
|
|
|
|
parseColorGroup(name: string): string | null {
|
|
const m = name.match(/\[([^\]]+)\]/);
|
|
return m?.[1] ?? null;
|
|
}
|
|
|
|
private generateWSkus(pMetaProduct: PMetaProduct): DeepPartial<Webflow.Products.Skus.Sku>[] {
|
|
const wSkus: DeepPartial<Webflow.Products.Skus.Sku>[] = [];
|
|
for (const { colorGroup, product: pProduct } of pMetaProduct.entries) {
|
|
const isColorGrouped = colorGroup !== null;
|
|
for (const pVariant of pProduct.sync_variants) {
|
|
if (isColorGrouped) {
|
|
// Only include sizes present across every color variant.
|
|
const sizeInAll = pMetaProduct.entries.every((e) =>
|
|
e.product.sync_variants.some((sv) => sv.size === pVariant.size)
|
|
);
|
|
if (!sizeInAll) continue;
|
|
}
|
|
|
|
const color = isColorGrouped ?
|
|
colorGroup :
|
|
pVariant.color;
|
|
|
|
this.log.debug(
|
|
{ color, size: pVariant.size, retailPrice: pVariant.retail_price },
|
|
"generating webflow SKU from printful variant"
|
|
);
|
|
|
|
wSkus.push({
|
|
id: pVariant.external_id,
|
|
fieldData: {
|
|
name: pVariant.name,
|
|
slug: formatSlug(pVariant.name),
|
|
"sku-values": {
|
|
color,
|
|
size: pVariant.size,
|
|
},
|
|
price: {
|
|
value: Math.round(+pVariant.retail_price * 100),
|
|
unit: pVariant.currency,
|
|
currency: pVariant.currency,
|
|
},
|
|
"main-image": PrintfulClient.Util.getVariantMainImage(pVariant),
|
|
},
|
|
});
|
|
}
|
|
}
|
|
|
|
return wSkus;
|
|
}
|
|
|
|
async generatePMetaProducts(
|
|
allWProducts: Webflow.Products.ProductAndSkus[],
|
|
allPProducts: Printful.Products.SyncProduct[],
|
|
opt: ProductSyncerOptions,
|
|
) {
|
|
const metaNameFilter = opt.filter?.pProductIds
|
|
?.map((id) => allPProducts.find((p) => p.id === id))
|
|
?.filter((p) => p !== undefined)
|
|
?.map((p) => this.getPMetaProductName(p));
|
|
|
|
const pMetaProducts: PMetaProduct[] = [];
|
|
for (const pProduct of allPProducts) {
|
|
const metaName = this.getPMetaProductName(pProduct);
|
|
const colorGroup = this.parseColorGroup(pProduct.name);
|
|
const wProductId = this.isPProductSynced(pProduct, allWProducts) ?
|
|
pProduct.external_id.split("-")[0] ?? "" :
|
|
"";
|
|
|
|
if (metaNameFilter && !metaNameFilter.includes(metaName)) continue;
|
|
|
|
let pMetaProduct = pMetaProducts.find((mp) => mp.name === metaName);
|
|
if (!pMetaProduct) {
|
|
this.log.debug({ metaName, colorGroup, wProductId }, "generating printful meta product");
|
|
pMetaProduct = {
|
|
name: metaName,
|
|
wProductId,
|
|
entries: [],
|
|
};
|
|
pMetaProducts.push(pMetaProduct);
|
|
} else if (!pMetaProduct.wProductId && wProductId) {
|
|
// Prefer a non-empty wProductId so a newly added color doesn't shadow an already-synced color's ID.
|
|
pMetaProduct.wProductId = wProductId;
|
|
}
|
|
|
|
const fullPProduct = await this.Printful.Products.get(pProduct.id);
|
|
if (!fullPProduct) throw new Error(`Printful product ${pProduct.id} not found`);
|
|
|
|
const isDuplicate = allPProducts.some((p) => p.id !== pProduct.id && p.name === pProduct.name);
|
|
if (isDuplicate) this.log.warn({ pProductName: pProduct.name }, "found duplicate printful product");
|
|
|
|
this.log.debug({ name: metaName, colorGroup }, "adding entry to printful meta product");
|
|
pMetaProduct.entries.push({ colorGroup, product: fullPProduct });
|
|
}
|
|
|
|
return pMetaProducts;
|
|
}
|
|
|
|
getPMetaProductName(pProduct: Printful.Products.SyncProduct): string {
|
|
const color = this.parseColorGroup(pProduct.name);
|
|
if (color) return pProduct.name.replace(`[${color}]`, "").trimEnd();
|
|
return pProduct.name;
|
|
}
|
|
|
|
private resolveWSku(
|
|
existingSkus: Webflow.Products.Skus.Sku[],
|
|
color: string | undefined,
|
|
size: string | undefined,
|
|
id?: string,
|
|
): Webflow.Products.Skus.Sku | undefined {
|
|
return existingSkus.find(
|
|
(sku) =>
|
|
(id && sku.id === id) ||
|
|
(sku.fieldData["sku-values"]?.["color"] === color &&
|
|
sku.fieldData["sku-values"]?.["size"] === size),
|
|
);
|
|
}
|
|
|
|
private isPProductSynced(pProduct: Printful.Products.SyncProduct, allWProducts: Webflow.Products.ProductAndSkus[]) {
|
|
return allWProducts.some((wp) => wp.product.id === pProduct.external_id.split("-")[0]);
|
|
}
|
|
}
|