Code
    Shopify AI Product OptimizerUpdated Jul 13, 2026TS

    Shopify AI Product Optimizer Seo Analyzer source

    Imported TypeScript file from worker/services/seo-analyzer.ts.

    Source file

    worker/services/seo-analyzer.ts

    TypeScript294 lines
    1. /**
    2. * Deterministic SEO Analyzer
    3. *
    4. * Runs a set of deterministic checks on product data to produce
    5. * a normalized SEO score and list of issues.
    6. */
    8. export interface SEOIssue {
    9. code: string;
    10. severity: "critical" | "warning" | "info";
    11. field: string;
    12. message: string;
    13. currentValue?: string;
    14. }
    16. export interface SEOAnalysis {
    17. score: number;
    18. issues: SEOIssue[];
    19. checks: {
    20. passed: string[];
    21. failed: string[];
    22. };
    23. }
    25. interface ProductData {
    26. id: string;
    27. title?: string;
    28. handle?: string;
    29. descriptionHtml?: string;
    30. seo?: {
    31. title?: string;
    32. description?: string;
    33. };
    34. productType?: string;
    35. vendor?: string;
    36. tags?: string[];
    37. options?: Array<{ name: string; values: string[] }>;
    38. variants?: {
    39. edges?: Array<{
    40. node: {
    41. sku?: string;
    42. barcode?: string;
    43. };
    44. }>;
    45. };
    46. }
    48. const CHECKS = [
    49. {
    50. code: "title_length",
    51. field: "title",
    52. severity: "warning" as const,
    53. weight: 5,
    54. check: (p: ProductData) => {
    55. const title = p.title || "";
    56. return title.length >= 20 && title.length <= 70;
    57. },
    58. message: (p: ProductData) => {
    59. const len = (p.title || "").length;
    60. if (len < 20) return `Title is too short (${len} chars). Aim for 20-70 characters.`;
    61. return `Title is too long (${len} chars). Aim for 20-70 characters.`;
    62. },
    63. },
    64. {
    65. code: "title_keywords",
    66. field: "title",
    67. severity: "info" as const,
    68. weight: 3,
    69. check: (p: ProductData) => {
    70. const title = (p.title || "").toLowerCase();
    71. // Check if title contains product type or meaningful keywords
    72. const productType = (p.productType || "").toLowerCase();
    73. return productType ? title.includes(productType) : true;
    74. },
    75. message: () => "Consider including the product type in the title for better SEO.",
    76. },
    77. {
    78. code: "seo_title_set",
    79. field: "seoTitle",
    80. severity: "critical" as const,
    81. weight: 10,
    82. check: (p: ProductData) => !!p.seo?.title?.trim(),
    83. message: () => "SEO title is not set. This will use the product title as the meta title.",
    84. },
    85. {
    86. code: "seo_title_length",
    87. field: "seoTitle",
    88. severity: "warning" as const,
    89. weight: 5,
    90. check: (p: ProductData) => {
    91. const title = p.seo?.title || "";
    92. if (!title) return true; // Skip if not set
    93. return title.length >= 30 && title.length <= 60;
    94. },
    95. message: (p: ProductData) => {
    96. const len = (p.seo?.title || "").length;
    97. if (len < 30) return `SEO title is too short (${len} chars). Aim for 30-60 characters.`;
    98. return `SEO title is too long (${len} chars). May be truncated in search results.`;
    99. },
    100. },
    101. {
    102. code: "seo_description_set",
    103. field: "seoDescription",
    104. severity: "critical" as const,
    105. weight: 10,
    106. check: (p: ProductData) => !!p.seo?.description?.trim(),
    107. message: () => "Meta description is not set. Search engines will use auto-generated text.",
    108. },
    109. {
    110. code: "seo_description_length",
    111. field: "seoDescription",
    112. severity: "warning" as const,
    113. weight: 5,
    114. check: (p: ProductData) => {
    115. const desc = p.seo?.description || "";
    116. if (!desc) return true; // Skip if not set
    117. return desc.length >= 120 && desc.length <= 160;
    118. },
    119. message: (p: ProductData) => {
    120. const len = (p.seo?.description || "").length;
    121. if (len < 120) return `Meta description is too short (${len} chars). Aim for 120-160 characters.`;
    122. return `Meta description is too long (${len} chars). Will be truncated in search results.`;
    123. },
    124. },
    125. {
    126. code: "handle_quality",
    127. field: "handle",
    128. severity: "warning" as const,
    129. weight: 5,
    130. check: (p: ProductData) => {
    131. const handle = p.handle || "";
    132. // Check for good handle practices
    133. return (
    134. handle.length > 3 &&
    135. handle.length < 100 &&
    136. !handle.includes("--") &&
    137. !/\d{10,}/.test(handle) // No long number sequences
    138. );
    139. },
    140. message: () => "Product handle could be improved for better URL structure.",
    141. },
    142. {
    143. code: "description_exists",
    144. field: "description",
    145. severity: "critical" as const,
    146. weight: 10,
    147. check: (p: ProductData) => {
    148. const desc = p.descriptionHtml || "";
    149. const textContent = desc.replace(/<[^>]*>/g, "").trim();
    150. return textContent.length > 0;
    151. },
    152. message: () => "Product description is empty. Add a description to improve SEO.",
    153. },
    154. {
    155. code: "description_length",
    156. field: "description",
    157. severity: "warning" as const,
    158. weight: 5,
    159. check: (p: ProductData) => {
    160. const desc = p.descriptionHtml || "";
    161. const textContent = desc.replace(/<[^>]*>/g, "").trim();
    162. return textContent.length >= 100;
    163. },
    164. message: (p: ProductData) => {
    165. const len = (p.descriptionHtml || "").replace(/<[^>]*>/g, "").trim().length;
    166. return `Description is too short (${len} chars). Aim for at least 100 characters.`;
    167. },
    168. },
    169. {
    170. code: "description_structure",
    171. field: "description",
    172. severity: "info" as const,
    173. weight: 3,
    174. check: (p: ProductData) => {
    175. const desc = p.descriptionHtml || "";
    176. // Check for some structure (headings, lists, paragraphs)
    177. return (
    178. desc.includes("<p>") ||
    179. desc.includes("<ul>") ||
    180. desc.includes("<h")
    181. );
    182. },
    183. message: () => "Consider using structured HTML (paragraphs, lists) in the description.",
    184. },
    185. {
    186. code: "has_tags",
    187. field: "tags",
    188. severity: "info" as const,
    189. weight: 3,
    190. check: (p: ProductData) => (p.tags?.length || 0) >= 3,
    191. message: () => "Add more tags to improve internal categorization and discoverability.",
    192. },
    193. {
    194. code: "has_product_type",
    195. field: "productType",
    196. severity: "warning" as const,
    197. weight: 5,
    198. check: (p: ProductData) => !!p.productType?.trim(),
    199. message: () => "Product type is not set. This helps with categorization and filtering.",
    200. },
    201. {
    202. code: "has_vendor",
    203. field: "vendor",
    204. severity: "info" as const,
    205. weight: 2,
    206. check: (p: ProductData) => !!p.vendor?.trim(),
    207. message: () => "Vendor is not set.",
    208. },
    209. {
    210. code: "has_sku",
    211. field: "variants",
    212. severity: "info" as const,
    213. weight: 3,
    214. check: (p: ProductData) => {
    215. const variants = p.variants?.edges || [];
    216. return variants.every((v) => !!v.node.sku?.trim());
    217. },
    218. message: () => "Some variants are missing SKUs. SKUs help with inventory and search.",
    219. },
    220. {
    221. code: "consistent_options",
    222. field: "options",
    223. severity: "info" as const,
    224. weight: 2,
    225. check: (p: ProductData) => {
    226. const options = p.options || [];
    227. // Check for consistent option naming (capitalization)
    228. return options.every((opt) =>
    229. opt.name === opt.name.charAt(0).toUpperCase() + opt.name.slice(1)
    230. );
    231. },
    232. message: () => "Option names should be consistently capitalized.",
    233. },
    234. ];
    236. export function analyzeProductSEO(product: ProductData): SEOAnalysis {
    237. const issues: SEOIssue[] = [];
    238. const passed: string[] = [];
    239. const failed: string[] = [];
    240. let totalWeight = 0;
    241. let earnedWeight = 0;
    243. for (const check of CHECKS) {
    244. totalWeight += check.weight;
    246. const result = check.check(product);
    248. if (result) {
    249. passed.push(check.code);
    250. earnedWeight += check.weight;
    251. } else {
    252. failed.push(check.code);
    253. issues.push({
    254. code: check.code,
    255. severity: check.severity,
    256. field: check.field,
    257. message: check.message(product),
    258. currentValue: getFieldValue(product, check.field),
    259. });
    260. }
    261. }
    263. // Calculate score as percentage
    264. const score = Math.round((earnedWeight / totalWeight) * 100);
    266. return {
    267. score,
    268. issues,
    269. checks: { passed, failed },
    270. };
    271. }
    273. function getFieldValue(product: ProductData, field: string): string | undefined {
    274. switch (field) {
    275. case "title":
    276. return product.title;
    277. case "seoTitle":
    278. return product.seo?.title;
    279. case "seoDescription":
    280. return product.seo?.description;
    281. case "description":
    282. return product.descriptionHtml;
    283. case "handle":
    284. return product.handle;
    285. case "productType":
    286. return product.productType;
    287. case "vendor":
    288. return product.vendor;
    289. case "tags":
    290. return product.tags?.join(", ");
    291. default:
    292. return undefined;
    293. }
    294. }