@htlkg/data 0.0.1

package/dist/client/index.d.ts

@@ -0,0 +1,70 @@
+import { AstroCookies } from 'astro';
+import { generateClient as generateClient$1 } from 'aws-amplify/data';
+
+/**
+ * GraphQL Client for @htlkg/data
+ *
+ * Provides both client-side and server-side GraphQL capabilities using AWS Amplify Data.
+ * The server-side functions use the Amplify Astro adapter for proper SSR support.
+ */
+
+/**
+ * Generate a client-side GraphQL client for use in Vue components and browser contexts
+ * This is SSR-safe and should be called within a component's setup function or after hydration
+ *
+ * @example
+ * ```typescript
+ * import type { Schema } from '@backend/data/resource';
+ * import { generateClient } from '@htlkg/data/client';
+ *
+ * const client = generateClient<Schema>();
+ * const { data: brands } = await client.models.Brand.list();
+ * ```
+ */
+declare function generateClient<TSchema extends Record<string, unknown> = Record<string, unknown>>(): ReturnType<typeof generateClient$1<TSchema>>;
+/**
+ * Configuration for Amplify Astro adapter
+ */
+interface AstroAmplifyConfig {
+    API?: {
+        GraphQL?: {
+            endpoint: string;
+            region: string;
+            defaultAuthMode: string;
+        };
+    };
+    Auth?: {
+        Cognito?: {
+            userPoolId: string;
+            userPoolClientId: string;
+            identityPoolId?: string;
+        };
+    };
+}
+/**
+ * Generate a server-side GraphQL client with cookie-based authentication
+ * Use this in Astro pages and API routes for server-side GraphQL operations
+ *
+ * Note: This is a placeholder that will be properly implemented once the
+ * Amplify Astro adapter is migrated to the modular architecture.
+ * For now, import generateServerClient from @htlkg/shared/lib/graphql directly.
+ *
+ * @example
+ * ```typescript
+ * import type { Schema } from '../amplify/data/resource';
+ * import { generateServerClient } from '@htlkg/data/client';
+ * import outputs from '../amplify_outputs.json';
+ *
+ * const client = generateServerClient<Schema>({
+ *   cookies: Astro.cookies,
+ *   config: outputs
+ * });
+ * const { data: brands } = await client.models.Brand.list();
+ * ```
+ */
+declare function generateServerClient<TSchema extends Record<string, unknown> = Record<string, unknown>>(options: {
+    cookies: AstroCookies;
+    config: AstroAmplifyConfig;
+}): any;
+
+export { type AstroAmplifyConfig, generateClient, generateServerClient };

package/dist/client/index.js

@@ -0,0 +1,33 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+
+// ../../node_modules/.pnpm/aws-amplify@6.15.8/node_modules/aws-amplify/dist/esm/api/index.mjs
+var api_exports = {};
+__reExport(api_exports, api_star);
+import * as api_star from "@aws-amplify/api";
+
+// src/client/index.ts
+function generateClient() {
+  return (0, api_exports.generateClient)();
+}
+function generateServerClient(options) {
+  throw new Error(
+    "[generateServerClient] Not yet implemented in modular architecture. Please use generateServerClient from @htlkg/shared/lib/graphql for now. This will be properly implemented when the Amplify Astro adapter is migrated."
+  );
+}
+export {
+  generateClient,
+  generateServerClient
+};
+//# sourceMappingURL=index.js.map

package/dist/client/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../node_modules/.pnpm/aws-amplify@6.15.8/node_modules/aws-amplify/dist/esm/api/index.mjs","../../src/client/index.ts"],"sourcesContent":["export * from '@aws-amplify/api';\n//# sourceMappingURL=index.mjs.map\n","/**\n * GraphQL Client for @htlkg/data\n *\n * Provides both client-side and server-side GraphQL capabilities using AWS Amplify Data.\n * The server-side functions use the Amplify Astro adapter for proper SSR support.\n */\n\nimport type { AstroCookies } from \"astro\";\nimport { generateClient as generateDataClient } from \"aws-amplify/data\";\n\n/**\n * Generate a client-side GraphQL client for use in Vue components and browser contexts\n * This is SSR-safe and should be called within a component's setup function or after hydration\n *\n * @example\n * ```typescript\n * import type { Schema } from '@backend/data/resource';\n * import { generateClient } from '@htlkg/data/client';\n *\n * const client = generateClient<Schema>();\n * const { data: brands } = await client.models.Brand.list();\n * ```\n */\nexport function generateClient<\n\tTSchema extends Record<string, unknown> = Record<string, unknown>,\n>(): ReturnType<typeof generateDataClient<TSchema>> {\n\treturn generateDataClient<TSchema>();\n}\n\n/**\n * Configuration for Amplify Astro adapter\n */\nexport interface AstroAmplifyConfig {\n\tAPI?: {\n\t\tGraphQL?: {\n\t\t\tendpoint: string;\n\t\t\tregion: string;\n\t\t\tdefaultAuthMode: string;\n\t\t};\n\t};\n\tAuth?: {\n\t\tCognito?: {\n\t\t\tuserPoolId: string;\n\t\t\tuserPoolClientId: string;\n\t\t\tidentityPoolId?: string;\n\t\t};\n\t};\n}\n\n/**\n * Generate a server-side GraphQL client with cookie-based authentication\n * Use this in Astro pages and API routes for server-side GraphQL operations\n *\n * Note: This is a placeholder that will be properly implemented once the\n * Amplify Astro adapter is migrated to the modular architecture.\n * For now, import generateServerClient from @htlkg/shared/lib/graphql directly.\n *\n * @example\n * ```typescript\n * import type { Schema } from '../amplify/data/resource';\n * import { generateServerClient } from '@htlkg/data/client';\n * import outputs from '../amplify_outputs.json';\n *\n * const client = generateServerClient<Schema>({\n *   cookies: Astro.cookies,\n *   config: outputs\n * });\n * const { data: brands } = await client.models.Brand.list();\n * ```\n */\nexport function generateServerClient<\n\tTSchema extends Record<string, unknown> = Record<string, unknown>,\n>(options: { cookies: AstroCookies; config: AstroAmplifyConfig }): any {\n\tthrow new Error(\n\t\t\"[generateServerClient] Not yet implemented in modular architecture. \" +\n\t\t\"Please use generateServerClient from @htlkg/shared/lib/graphql for now. \" +\n\t\t\"This will be properly implemented when the Amplify Astro adapter is migrated.\",\n\t);\n}\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,0BAAc;;;ACuBP,SAAS,iBAEoC;AACnD,aAAO,YAAAA,gBAA4B;AACpC;AA2CO,SAAS,qBAEd,SAAqE;AACtE,QAAM,IAAI;AAAA,IACT;AAAA,EAGD;AACD;","names":["generateDataClient"]}

package/dist/content-collections/index.d.ts

@@ -0,0 +1,246 @@
+import { z } from 'zod';
+
+/**
+ * AppSync Sync for Content Collections
+ *
+ * Fetches data from Admin's AppSync API for use in Content Collections.
+ */
+interface SyncOptions {
+    /** AppSync API configuration */
+    apiConfig: {
+        endpoint: string;
+        region: string;
+        apiKey?: string;
+    };
+    /** Authorization mode (default: 'apiKey') */
+    authMode?: "apiKey" | "userPool" | "iam";
+    /** Limit for list queries */
+    limit?: number;
+}
+interface SyncResult<T> {
+    data: T[];
+    errors: Array<{
+        message: string;
+    }> | null;
+}
+/**
+ * Fetch brands from AppSync
+ */
+declare function fetchBrands(options: SyncOptions): Promise<SyncResult<any>>;
+/**
+ * Fetch accounts from AppSync
+ */
+declare function fetchAccounts(options: SyncOptions): Promise<SyncResult<any>>;
+/**
+ * Fetch product instances from AppSync
+ */
+declare function fetchProductInstances(options: SyncOptions): Promise<SyncResult<any>>;
+/**
+ * Fetch products from AppSync
+ */
+declare function fetchProducts(options: SyncOptions): Promise<SyncResult<any>>;
+
+/**
+ * Content Collections Generator
+ *
+ * Generates Astro Content Collections from AppSync data.
+ * Fetches brands, accounts, and product instances and writes them as JSON files.
+ */
+
+interface GeneratorOptions extends SyncOptions {
+    /** Output directory for content collections (default: 'src/content') */
+    outputDir?: string;
+    /** Whether to validate data against schemas (default: true) */
+    validate?: boolean;
+    /** Whether to continue on errors (default: true) */
+    continueOnError?: boolean;
+}
+interface GeneratorResult {
+    brands: {
+        count: number;
+        errors: string[];
+    };
+    accounts: {
+        count: number;
+        errors: string[];
+    };
+    productInstances: {
+        count: number;
+        errors: string[];
+    };
+    products: {
+        count: number;
+        errors: string[];
+    };
+}
+/**
+ * Generate Content Collections from AppSync
+ *
+ * @example
+ * ```typescript
+ * import { generateContentCollections } from '@htlkg/data/content-collections';
+ *
+ * const result = await generateContentCollections({
+ *   apiConfig: {
+ *     endpoint: process.env.APPSYNC_ENDPOINT,
+ *     region: 'us-east-1',
+ *     apiKey: process.env.APPSYNC_API_KEY
+ *   },
+ *   outputDir: 'src/content'
+ * });
+ *
+ * console.log(`Generated ${result.brands.count} brands`);
+ * ```
+ */
+declare function generateContentCollections(options: GeneratorOptions): Promise<GeneratorResult>;
+/**
+ * Sync data from AppSync (alias for generateContentCollections)
+ */
+declare const syncFromAppSync: typeof generateContentCollections;
+
+/**
+ * Zod Schemas for Content Collections
+ *
+ * Defines validation schemas for brands, accounts, and product instances
+ * that will be synced from AppSync to Astro Content Collections.
+ */
+
+/**
+ * Brand schema for content collections
+ */
+declare const brandSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    accountId: z.ZodString;
+    logo: z.ZodOptional<z.ZodString>;
+    timezone: z.ZodString;
+    status: z.ZodEnum<["active", "inactive", "maintenance", "suspended"]>;
+    settings: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    accountId: string;
+    timezone: string;
+    status: "active" | "inactive" | "maintenance" | "suspended";
+    settings: Record<string, any>;
+    logo?: string | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+}, {
+    id: string;
+    name: string;
+    accountId: string;
+    timezone: string;
+    status: "active" | "inactive" | "maintenance" | "suspended";
+    logo?: string | undefined;
+    settings?: Record<string, any> | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+}>;
+type BrandData = z.infer<typeof brandSchema>;
+/**
+ * Account schema for content collections
+ */
+declare const accountSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    logo: z.ZodOptional<z.ZodString>;
+    subscription: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+    settings: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    settings: Record<string, any>;
+    subscription: Record<string, any>;
+    logo?: string | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+}, {
+    id: string;
+    name: string;
+    logo?: string | undefined;
+    settings?: Record<string, any> | undefined;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+    subscription?: Record<string, any> | undefined;
+}>;
+type AccountData = z.infer<typeof accountSchema>;
+/**
+ * Product Instance schema for content collections
+ */
+declare const productInstanceSchema: z.ZodObject<{
+    id: z.ZodString;
+    productId: z.ZodString;
+    productName: z.ZodString;
+    brandId: z.ZodString;
+    accountId: z.ZodString;
+    enabled: z.ZodBoolean;
+    config: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+    version: z.ZodString;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    accountId: string;
+    productId: string;
+    productName: string;
+    brandId: string;
+    enabled: boolean;
+    config: Record<string, any>;
+    version: string;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+}, {
+    id: string;
+    accountId: string;
+    productId: string;
+    productName: string;
+    brandId: string;
+    enabled: boolean;
+    version: string;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+    config?: Record<string, any> | undefined;
+}>;
+type ProductInstanceData = z.infer<typeof productInstanceSchema>;
+/**
+ * Product schema for content collections
+ */
+declare const productSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodString;
+    schema: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+    uiSchema: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+    defaultConfig: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+    isActive: z.ZodBoolean;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    version: string;
+    schema: Record<string, any>;
+    uiSchema: Record<string, any>;
+    defaultConfig: Record<string, any>;
+    isActive: boolean;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+}, {
+    id: string;
+    name: string;
+    version: string;
+    isActive: boolean;
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+    schema?: Record<string, any> | undefined;
+    uiSchema?: Record<string, any> | undefined;
+    defaultConfig?: Record<string, any> | undefined;
+}>;
+type ProductData = z.infer<typeof productSchema>;
+
+export { type AccountData, type BrandData, type GeneratorOptions, type GeneratorResult, type ProductData, type ProductInstanceData, type SyncOptions, type SyncResult, accountSchema, brandSchema, fetchAccounts, fetchBrands, fetchProductInstances, fetchProducts, generateContentCollections, productInstanceSchema, productSchema, syncFromAppSync };

package/dist/content-collections/index.js

@@ -0,0 +1,337 @@
+// src/content-collections/generator.ts
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+
+// src/content-collections/sync.ts
+import { generateClient } from "@aws-amplify/api";
+async function fetchBrands(options) {
+  try {
+    const client = generateClient({
+      authMode: options.authMode || "apiKey"
+    });
+    const { data, errors } = await client.models.Brand.list({
+      limit: options.limit || 1e3
+    });
+    return {
+      data: data || [],
+      errors: errors || null
+    };
+  } catch (error) {
+    console.error("[fetchBrands] Error:", error);
+    return {
+      data: [],
+      errors: [{ message: error.message }]
+    };
+  }
+}
+async function fetchAccounts(options) {
+  try {
+    const client = generateClient({
+      authMode: options.authMode || "apiKey"
+    });
+    const { data, errors } = await client.models.Account.list({
+      limit: options.limit || 1e3
+    });
+    return {
+      data: data || [],
+      errors: errors || null
+    };
+  } catch (error) {
+    console.error("[fetchAccounts] Error:", error);
+    return {
+      data: [],
+      errors: [{ message: error.message }]
+    };
+  }
+}
+async function fetchProductInstances(options) {
+  try {
+    const client = generateClient({
+      authMode: options.authMode || "apiKey"
+    });
+    const { data, errors } = await client.models.ProductInstance.list(
+      {
+        limit: options.limit || 1e3
+      }
+    );
+    return {
+      data: data || [],
+      errors: errors || null
+    };
+  } catch (error) {
+    console.error("[fetchProductInstances] Error:", error);
+    return {
+      data: [],
+      errors: [{ message: error.message }]
+    };
+  }
+}
+async function fetchProducts(options) {
+  try {
+    const client = generateClient({
+      authMode: options.authMode || "apiKey"
+    });
+    const { data, errors } = await client.models.Product.list({
+      limit: options.limit || 1e3
+    });
+    return {
+      data: data || [],
+      errors: errors || null
+    };
+  } catch (error) {
+    console.error("[fetchProducts] Error:", error);
+    return {
+      data: [],
+      errors: [{ message: error.message }]
+    };
+  }
+}
+
+// src/content-collections/schemas.ts
+import { z } from "zod";
+var brandSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  accountId: z.string(),
+  logo: z.string().optional(),
+  timezone: z.string(),
+  status: z.enum(["active", "inactive", "maintenance", "suspended"]),
+  settings: z.record(z.any()).optional().default({}),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional()
+});
+var accountSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  logo: z.string().optional(),
+  subscription: z.record(z.any()).optional().default({}),
+  settings: z.record(z.any()).optional().default({}),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional()
+});
+var productInstanceSchema = z.object({
+  id: z.string(),
+  productId: z.string(),
+  productName: z.string(),
+  brandId: z.string(),
+  accountId: z.string(),
+  enabled: z.boolean(),
+  config: z.record(z.any()).optional().default({}),
+  version: z.string(),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional()
+});
+var productSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  version: z.string(),
+  schema: z.record(z.any()).optional().default({}),
+  uiSchema: z.record(z.any()).optional().default({}),
+  defaultConfig: z.record(z.any()).optional().default({}),
+  isActive: z.boolean(),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional()
+});
+
+// src/content-collections/generator.ts
+async function generateContentCollections(options) {
+  const {
+    outputDir = "src/content",
+    validate = true,
+    continueOnError = true
+  } = options;
+  const result = {
+    brands: { count: 0, errors: [] },
+    accounts: { count: 0, errors: [] },
+    productInstances: { count: 0, errors: [] },
+    products: { count: 0, errors: [] }
+  };
+  const brandsDir = join(outputDir, "brands");
+  const accountsDir = join(outputDir, "accounts");
+  const productInstancesDir = join(outputDir, "product-instances");
+  const productsDir = join(outputDir, "products");
+  for (const dir of [brandsDir, accountsDir, productInstancesDir, productsDir]) {
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+  try {
+    console.log("[generateContentCollections] Fetching brands...");
+    const brandsResult = await fetchBrands(options);
+    if (brandsResult.errors && !continueOnError) {
+      throw new Error(
+        `Failed to fetch brands: ${brandsResult.errors[0]?.message}`
+      );
+    }
+    if (brandsResult.errors) {
+      result.brands.errors.push(
+        ...brandsResult.errors.map((e) => e.message)
+      );
+    }
+    for (const brand of brandsResult.data) {
+      try {
+        if (validate) {
+          brandSchema.parse(brand);
+        }
+        const filename = join(brandsDir, `${brand.id}.json`);
+        writeFileSync(filename, JSON.stringify(brand, null, 2));
+        result.brands.count++;
+      } catch (error) {
+        const errorMsg = `Failed to process brand ${brand.id}: ${error.message}`;
+        console.error(`[generateContentCollections] ${errorMsg}`);
+        result.brands.errors.push(errorMsg);
+        if (!continueOnError) {
+          throw error;
+        }
+      }
+    }
+    console.log(
+      `[generateContentCollections] Generated ${result.brands.count} brands`
+    );
+  } catch (error) {
+    const errorMsg = `Failed to generate brands: ${error.message}`;
+    console.error(`[generateContentCollections] ${errorMsg}`);
+    result.brands.errors.push(errorMsg);
+    if (!continueOnError) {
+      throw error;
+    }
+  }
+  try {
+    console.log("[generateContentCollections] Fetching accounts...");
+    const accountsResult = await fetchAccounts(options);
+    if (accountsResult.errors && !continueOnError) {
+      throw new Error(
+        `Failed to fetch accounts: ${accountsResult.errors[0]?.message}`
+      );
+    }
+    if (accountsResult.errors) {
+      result.accounts.errors.push(
+        ...accountsResult.errors.map((e) => e.message)
+      );
+    }
+    for (const account of accountsResult.data) {
+      try {
+        if (validate) {
+          accountSchema.parse(account);
+        }
+        const filename = join(accountsDir, `${account.id}.json`);
+        writeFileSync(filename, JSON.stringify(account, null, 2));
+        result.accounts.count++;
+      } catch (error) {
+        const errorMsg = `Failed to process account ${account.id}: ${error.message}`;
+        console.error(`[generateContentCollections] ${errorMsg}`);
+        result.accounts.errors.push(errorMsg);
+        if (!continueOnError) {
+          throw error;
+        }
+      }
+    }
+    console.log(
+      `[generateContentCollections] Generated ${result.accounts.count} accounts`
+    );
+  } catch (error) {
+    const errorMsg = `Failed to generate accounts: ${error.message}`;
+    console.error(`[generateContentCollections] ${errorMsg}`);
+    result.accounts.errors.push(errorMsg);
+    if (!continueOnError) {
+      throw error;
+    }
+  }
+  try {
+    console.log("[generateContentCollections] Fetching product instances...");
+    const productInstancesResult = await fetchProductInstances(options);
+    if (productInstancesResult.errors && !continueOnError) {
+      throw new Error(
+        `Failed to fetch product instances: ${productInstancesResult.errors[0]?.message}`
+      );
+    }
+    if (productInstancesResult.errors) {
+      result.productInstances.errors.push(
+        ...productInstancesResult.errors.map((e) => e.message)
+      );
+    }
+    for (const instance of productInstancesResult.data) {
+      try {
+        if (validate) {
+          productInstanceSchema.parse(instance);
+        }
+        const filename = join(productInstancesDir, `${instance.id}.json`);
+        writeFileSync(filename, JSON.stringify(instance, null, 2));
+        result.productInstances.count++;
+      } catch (error) {
+        const errorMsg = `Failed to process product instance ${instance.id}: ${error.message}`;
+        console.error(`[generateContentCollections] ${errorMsg}`);
+        result.productInstances.errors.push(errorMsg);
+        if (!continueOnError) {
+          throw error;
+        }
+      }
+    }
+    console.log(
+      `[generateContentCollections] Generated ${result.productInstances.count} product instances`
+    );
+  } catch (error) {
+    const errorMsg = `Failed to generate product instances: ${error.message}`;
+    console.error(`[generateContentCollections] ${errorMsg}`);
+    result.productInstances.errors.push(errorMsg);
+    if (!continueOnError) {
+      throw error;
+    }
+  }
+  try {
+    console.log("[generateContentCollections] Fetching products...");
+    const productsResult = await fetchProducts(options);
+    if (productsResult.errors && !continueOnError) {
+      throw new Error(
+        `Failed to fetch products: ${productsResult.errors[0]?.message}`
+      );
+    }
+    if (productsResult.errors) {
+      result.products.errors.push(
+        ...productsResult.errors.map((e) => e.message)
+      );
+    }
+    for (const product of productsResult.data) {
+      try {
+        if (validate) {
+          productSchema.parse(product);
+        }
+        const filename = join(productsDir, `${product.id}.json`);
+        writeFileSync(filename, JSON.stringify(product, null, 2));
+        result.products.count++;
+      } catch (error) {
+        const errorMsg = `Failed to process product ${product.id}: ${error.message}`;
+        console.error(`[generateContentCollections] ${errorMsg}`);
+        result.products.errors.push(errorMsg);
+        if (!continueOnError) {
+          throw error;
+        }
+      }
+    }
+    console.log(
+      `[generateContentCollections] Generated ${result.products.count} products`
+    );
+  } catch (error) {
+    const errorMsg = `Failed to generate products: ${error.message}`;
+    console.error(`[generateContentCollections] ${errorMsg}`);
+    result.products.errors.push(errorMsg);
+    if (!continueOnError) {
+      throw error;
+    }
+  }
+  return result;
+}
+var syncFromAppSync = generateContentCollections;
+export {
+  accountSchema,
+  brandSchema,
+  fetchAccounts,
+  fetchBrands,
+  fetchProductInstances,
+  fetchProducts,
+  generateContentCollections,
+  productInstanceSchema,
+  productSchema,
+  syncFromAppSync
+};
+//# sourceMappingURL=index.js.map