@htlkg/data 0.0.2 → 0.0.3

package/src/content-collections/generator.ts

@@ -0,0 +1,314 @@
+/**
+ * Content Collections Generator
+ *
+ * Generates Astro Content Collections from AppSync data.
+ * Fetches brands, accounts, and product instances and writes them as JSON files.
+ */
+
+import { writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import {
+	fetchBrands,
+	fetchAccounts,
+	fetchProductInstances,
+	fetchProducts,
+	type SyncOptions,
+} from "./sync";
+import {
+	brandSchema,
+	accountSchema,
+	productInstanceSchema,
+	productSchema,
+	type BrandData,
+	type AccountData,
+	type ProductInstanceData,
+	type ProductData,
+} from "./schemas";
+
+const log = {
+	info: (msg: string) => console.info(`[content-collections] ${msg}`),
+	error: (msg: string) => console.error(`[content-collections] ${msg}`),
+};
+
+export 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;
+}
+
+export 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`);
+ * ```
+ */
+export async function generateContentCollections(
+	options: GeneratorOptions,
+): Promise<GeneratorResult> {
+	const {
+		outputDir = "src/content",
+		validate = true,
+		continueOnError = true,
+	} = options;
+
+	const result: GeneratorResult = {
+		brands: { count: 0, errors: [] },
+		accounts: { count: 0, errors: [] },
+		productInstances: { count: 0, errors: [] },
+		products: { count: 0, errors: [] },
+	};
+
+	// Ensure output directories exist
+	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 });
+		}
+	}
+
+	// Fetch and generate brands
+	try {
+		log.info("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 {
+				// Validate if enabled
+				if (validate) {
+					brandSchema.parse(brand);
+				}
+
+				// Write JSON file
+				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 as Error).message}`;
+				log.error(errorMsg);
+				result.brands.errors.push(errorMsg);
+
+				if (!continueOnError) {
+					throw error;
+				}
+			}
+		}
+
+		log.info(`Generated ${result.brands.count} brands`);
+	} catch (error) {
+		const errorMsg = `Failed to generate brands: ${(error as Error).message}`;
+		log.error(errorMsg);
+		result.brands.errors.push(errorMsg);
+
+		if (!continueOnError) {
+			throw error;
+		}
+	}
+
+	// Fetch and generate accounts
+	try {
+		log.info("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 {
+				// Validate if enabled
+				if (validate) {
+					accountSchema.parse(account);
+				}
+
+				// Write JSON file
+				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 as Error).message}`;
+				log.error(errorMsg);
+				result.accounts.errors.push(errorMsg);
+
+				if (!continueOnError) {
+					throw error;
+				}
+			}
+		}
+
+		log.info(`Generated ${result.accounts.count} accounts`);
+	} catch (error) {
+		const errorMsg = `Failed to generate accounts: ${(error as Error).message}`;
+		log.error(errorMsg);
+		result.accounts.errors.push(errorMsg);
+
+		if (!continueOnError) {
+			throw error;
+		}
+	}
+
+	// Fetch and generate product instances
+	try {
+		log.info("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 {
+				// Validate if enabled
+				if (validate) {
+					productInstanceSchema.parse(instance);
+				}
+
+				// Write JSON file
+				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 as Error).message}`;
+				log.error(errorMsg);
+				result.productInstances.errors.push(errorMsg);
+
+				if (!continueOnError) {
+					throw error;
+				}
+			}
+		}
+
+		log.info(`Generated ${result.productInstances.count} product instances`);
+	} catch (error) {
+		const errorMsg = `Failed to generate product instances: ${(error as Error).message}`;
+		log.error(errorMsg);
+		result.productInstances.errors.push(errorMsg);
+
+		if (!continueOnError) {
+			throw error;
+		}
+	}
+
+	// Fetch and generate products
+	try {
+		log.info("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 {
+				// Validate if enabled
+				if (validate) {
+					productSchema.parse(product);
+				}
+
+				// Write JSON file
+				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 as Error).message}`;
+				log.error(errorMsg);
+				result.products.errors.push(errorMsg);
+
+				if (!continueOnError) {
+					throw error;
+				}
+			}
+		}
+
+		log.info(`Generated ${result.products.count} products`);
+	} catch (error) {
+		const errorMsg = `Failed to generate products: ${(error as Error).message}`;
+		log.error(errorMsg);
+		result.products.errors.push(errorMsg);
+
+		if (!continueOnError) {
+			throw error;
+		}
+	}
+
+	return result;
+}
+
+/**
+ * Sync data from AppSync (alias for generateContentCollections)
+ */
+export const syncFromAppSync = generateContentCollections;

package/src/content-collections/index.ts

@@ -0,0 +1,32 @@
+/**
+ * Content Collections for @htlkg/data
+ *
+ * Provides functionality to generate Astro Content Collections from AppSync data.
+ */
+
+export {
+	generateContentCollections,
+	syncFromAppSync,
+	type GeneratorOptions,
+	type GeneratorResult,
+} from "./generator";
+
+export {
+	fetchBrands,
+	fetchAccounts,
+	fetchProductInstances,
+	fetchProducts,
+	type SyncOptions,
+	type SyncResult,
+} from "./sync";
+
+export {
+	brandSchema,
+	accountSchema,
+	productInstanceSchema,
+	productSchema,
+	type BrandData,
+	type AccountData,
+	type ProductInstanceData,
+	type ProductData,
+} from "./schemas";

package/src/content-collections/schemas.ts

@@ -0,0 +1,75 @@
+/**
+ * Zod Schemas for Content Collections
+ *
+ * Defines validation schemas for brands, accounts, and product instances
+ * that will be synced from AppSync to Astro Content Collections.
+ */
+
+import { z } from "zod";
+
+/**
+ * Brand schema for content collections
+ */
+export const 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(),
+});
+
+export type BrandData = z.infer<typeof brandSchema>;
+
+/**
+ * Account schema for content collections
+ */
+export const 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(),
+});
+
+export type AccountData = z.infer<typeof accountSchema>;
+
+/**
+ * Product Instance schema for content collections
+ */
+export const 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(),
+});
+
+export type ProductInstanceData = z.infer<typeof productInstanceSchema>;
+
+/**
+ * Product schema for content collections
+ */
+export const 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(),
+});
+
+export type ProductData = z.infer<typeof productSchema>;

package/src/content-collections/sync.ts

@@ -0,0 +1,139 @@
+/**
+ * AppSync Sync for Content Collections
+ *
+ * Fetches data from Admin's AppSync API for use in Content Collections.
+ */
+
+import { generateClient } from "@aws-amplify/api";
+
+export 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;
+}
+
+export interface SyncResult<T> {
+	data: T[];
+	errors: Array<{ message: string }> | null;
+}
+
+/**
+ * Fetch brands from AppSync
+ */
+export async function fetchBrands(
+	options: SyncOptions,
+): Promise<SyncResult<any>> {
+	try {
+		const client = generateClient({
+			authMode: options.authMode || "apiKey",
+		});
+
+		const { data, errors } = await (client as any).models.Brand.list({
+			limit: options.limit || 1000,
+		});
+
+		return {
+			data: data || [],
+			errors: errors || null,
+		};
+	} catch (error) {
+		console.error("[fetchBrands] Error:", error);
+		return {
+			data: [],
+			errors: [{ message: (error as Error).message }],
+		};
+	}
+}
+
+/**
+ * Fetch accounts from AppSync
+ */
+export async function fetchAccounts(
+	options: SyncOptions,
+): Promise<SyncResult<any>> {
+	try {
+		const client = generateClient({
+			authMode: options.authMode || "apiKey",
+		});
+
+		const { data, errors } = await (client as any).models.Account.list({
+			limit: options.limit || 1000,
+		});
+
+		return {
+			data: data || [],
+			errors: errors || null,
+		};
+	} catch (error) {
+		console.error("[fetchAccounts] Error:", error);
+		return {
+			data: [],
+			errors: [{ message: (error as Error).message }],
+		};
+	}
+}
+
+/**
+ * Fetch product instances from AppSync
+ */
+export async function fetchProductInstances(
+	options: SyncOptions,
+): Promise<SyncResult<any>> {
+	try {
+		const client = generateClient({
+			authMode: options.authMode || "apiKey",
+		});
+
+		const { data, errors } = await (client as any).models.ProductInstance.list(
+			{
+				limit: options.limit || 1000,
+			},
+		);
+
+		return {
+			data: data || [],
+			errors: errors || null,
+		};
+	} catch (error) {
+		console.error("[fetchProductInstances] Error:", error);
+		return {
+			data: [],
+			errors: [{ message: (error as Error).message }],
+		};
+	}
+}
+
+/**
+ * Fetch products from AppSync
+ */
+export async function fetchProducts(
+	options: SyncOptions,
+): Promise<SyncResult<any>> {
+	try {
+		const client = generateClient({
+			authMode: options.authMode || "apiKey",
+		});
+
+		const { data, errors } = await (client as any).models.Product.list({
+			limit: options.limit || 1000,
+		});
+
+		return {
+			data: data || [],
+			errors: errors || null,
+		};
+	} catch (error) {
+		console.error("[fetchProducts] Error:", error);
+		return {
+			data: [],
+			errors: [{ message: (error as Error).message }],
+		};
+	}
+}