@contentstorage/core 0.3.7 → 0.3.9

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { AppConfig } from './lib/configLoader.js';
-export { AppConfig };
+import { AppConfig, LanguageCode } from './types.js';
+export { AppConfig, LanguageCode };

package/dist/lib/configLoader.d.ts

@@ -1,6 +1,2 @@
-export interface AppConfig {
-    contentUrl: string;
-    contentDir: string;
-    typesOutputFile: string;
-}
+import { AppConfig } from '../types.js';
 export declare function loadConfig(): Promise<AppConfig>;

package/dist/lib/configLoader.js

@@ -1,6 +1,7 @@
 import path from 'path';
 import fs from 'fs';
 const DEFAULT_CONFIG = {
+    languageCodes: [],
     contentDir: path.join('src', 'assets', 'content'),
     typesOutputFile: path.join('src', 'generated', 'content-types.ts'),
 };
@@ -37,6 +38,7 @@ export async function loadConfig() {
     }
     // Resolve paths relative to the user's project root (process.cwd())
     const finalConfig = {
+        languageCodes: mergedConfig.languageCodes || [],
         contentUrl: mergedConfig.contentUrl,
         contentDir: path.resolve(process.cwd(), mergedConfig.contentDir),
         typesOutputFile: path.resolve(process.cwd(), mergedConfig.typesOutputFile),

package/dist/scripts/pull-content.js

@@ -6,59 +6,78 @@ import chalk from 'chalk';
 import { loadConfig } from '../lib/configLoader.js';
 export async function pullContent() {
     console.log(chalk.blue('Starting content pull...'));
+    // Load configuration (assuming this function is defined elsewhere and works)
     const config = await loadConfig();
-    console.log(chalk.gray(`Getting content from: ${config.contentUrl}`));
+    console.log(chalk.gray(`Content base URL: ${config.contentUrl}`));
     console.log(chalk.gray(`Saving content to: ${config.contentDir}`));
     try {
-        // Fetch data
-        const response = await axios.get(config.contentUrl);
-        const jsonData = response.data; // Assume axios parses JSON automatically
-        if (!jsonData) {
-            throw new Error('No data received from the URL.');
+        // Validate languageCodes array
+        if (!Array.isArray(config.languageCodes)) {
+            console.log(chalk.red(`Expected array from config.languageCodes, but received type ${typeof config.languageCodes}. Cannot pull files.`));
+            return; // Exit if languageCodes is not an array
         }
-        // Ensure the output directory exists
-        await fs.mkdir(config.contentDir, { recursive: true });
-        // --- How to save the data? ---
-        // Option 1: Save the entire response as one file (e.g., content.json)
-        // const outputPath = path.join(config.contentDir, 'content.json');
-        // await fs.writeFile(outputPath, JSON.stringify(jsonData, null, 2));
-        // console.log(chalk.green(`Content saved successfully to ${outputPath}`));
-        // Option 2: Assume the response is an ARRAY of objects, save each as a separate file
-        // This matches the requirement "use the first file from the directory" later
-        if (!Array.isArray(jsonData)) {
-            throw new Error(`Expected an array of objects from ${config.contentUrl}, but received type ${typeof jsonData}. Cannot save individual files.`);
-        }
-        if (jsonData.length === 0) {
-            console.log(chalk.yellow('Received empty array. No files to save.'));
-            return;
+        if (config.languageCodes.length === 0) {
+            console.log(chalk.yellow('config.languageCodes array is empty. No files to pull.'));
+            return; // Exit if languageCodes array is empty
         }
-        console.log(chalk.gray(`Received ${jsonData.length} items. Saving individually...`));
-        let filesSavedCount = 0;
-        for (let i = 0; i < jsonData.length; i++) {
-            const item = jsonData[i];
-            // Determine filename: use 'id' or 'slug' if available, otherwise use index
-            const filename = `${item.id || item.slug || i}.json`;
+        // Ensure the output directory exists (create it once before the loop)
+        await fs.mkdir(config.contentDir, { recursive: true });
+        // Process each language code
+        for (const languageCode of config.languageCodes) {
+            const fileUrl = `${config.contentUrl}/${languageCode}.json`;
+            const filename = `${languageCode}.json`;
             const outputPath = path.join(config.contentDir, filename);
+            console.log(chalk.blue(`\nProcessing language: ${languageCode}`));
+            console.log(chalk.gray(`Workspaceing from: ${fileUrl}`));
             try {
-                await fs.writeFile(outputPath, JSON.stringify(item, null, 2));
-                filesSavedCount++;
+                // Fetch data for the current language
+                const response = await axios.get(fileUrl);
+                const jsonData = response.data;
+                // Basic check for data existence, although axios usually throws for non-2xx responses
+                if (jsonData === undefined || jsonData === null) {
+                    throw new Error(`No data received from ${fileUrl} for language ${languageCode}.`);
+                }
+                // Validate that jsonData is a single, non-null JSON object (not an array)
+                // This check mirrors the original code's expectation for the content of a JSON file.
+                if (typeof jsonData !== 'object' ||
+                    Array.isArray(jsonData) /* jsonData === null is already covered */) {
+                    throw new Error(`Expected a single JSON object from ${fileUrl} for language ${languageCode}, but received type ${Array.isArray(jsonData) ? 'array' : typeof jsonData}. Cannot save the file.`);
+                }
+                console.log(chalk.green(`Received JSON for ${languageCode}. Saving to ${outputPath}`));
+                // Write the JSON data to the file
+                await fs.writeFile(outputPath, JSON.stringify(jsonData, null, 2));
+                console.log(chalk.green(`Successfully saved ${outputPath}`));
             }
-            catch (writeError) {
-                console.error(chalk.red(`Error saving file ${filename}:`), writeError.message);
-                // Optionally decide whether to continue or stop on error
+            catch (error) {
+                // Catch errors related to fetching or saving a single language file
+                console.error(chalk.red(`\nError processing language ${languageCode} from ${fileUrl}:`));
+                if (axios.isAxiosError(error)) {
+                    console.error(chalk.red(`  Status: ${error.response?.status}`));
+                    console.error(chalk.red(`Response Data: ${error.response?.data ? JSON.stringify(error.response.data) : 'N/A'}`));
+                    console.error(chalk.red(`  Message: ${error.message}`)); // Axios error message
+                }
+                else {
+                    // For non-Axios errors (e.g., manually thrown errors, fs errors)
+                    console.error(chalk.red(`  Error: ${error.message}`));
+                }
+                // Re-throw the error to be caught by the outer try-catch block,
+                // which will then call process.exit(1), maintaining original exit behavior on error.
+                throw error;
             }
         }
-        console.log(chalk.green(`Successfully saved ${filesSavedCount} files to ${config.contentDir}`));
+        console.log(chalk.green('\nAll content successfully pulled and saved.'));
     }
-    catch (error) {
-        console.error(chalk.red('Error fetching or saving content:'));
-        if (axios.isAxiosError(error)) {
-            console.error(chalk.red(`Status: ${error.response?.status}`));
-            console.error(chalk.red(`Data: ${JSON.stringify(error.response?.data)}`));
-        }
-        else {
-            console.error(chalk.red(error.message));
-        }
+    catch {
+        // Outer catch for setup errors (like loadConfig) or re-thrown errors from the loop
+        // The specific error details for a file operation would have been logged by the inner catch.
+        // This block provides a general failure message and ensures the process exits with an error code.
+        console.error(chalk.red('\n-----------------------------------------------------'));
+        console.error(chalk.red('Content pull failed due to an error. See details above.'));
+        // error.message from the re-thrown error will be implicitly part of the error object logged by some environments,
+        // or if you add console.error(error) here.
+        // The original code logged error.message at this level:
+        // if (error.message) console.error(chalk.red(`Underlying error: ${error.message}`));
+        console.error(chalk.red('-----------------------------------------------------'));
         process.exit(1); // Exit with error code
     }
 }

package/dist/types.d.ts

@@ -0,0 +1,7 @@
+export type AppConfig = {
+    languageCodes: LanguageCode[];
+    contentUrl: string;
+    contentDir: string;
+    typesOutputFile: string;
+};
+export type LanguageCode = 'SQ' | 'BE' | 'BS' | 'BG' | 'HR' | 'CS' | 'DA' | 'NL' | 'EN' | 'ET' | 'FI' | 'FR' | 'DE' | 'EL' | 'HU' | 'GA' | 'IT' | 'LV' | 'LT' | 'MK' | 'NO' | 'PL' | 'PT' | 'RO' | 'RU' | 'SR' | 'SK' | 'SL' | 'ES' | 'SV' | 'TR' | 'UK';

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -2,7 +2,7 @@
   "name": "@contentstorage/core",
   "author": "Kaido Hussar <kaidohus@gmail.com>",
   "homepage": "https://contentstorage.app",
-  "version": "0.3.7",
+  "version": "0.3.9",
   "type": "module",
   "description": "Fetch content from contentstorage and generate TypeScript types",
   "module": "dist/index.js",