@contentstorage/core 0.3.8 → 0.3.10

package/dist/helpers/defineConfig.d.ts

@@ -0,0 +1,6 @@
+import { AppConfig } from '../types.js';
+/**
+ * Helper function to define your application configuration.
+ * Provides autocompletion and type-checking for contentstorage.config.js files.
+ */
+export declare function defineConfig(config: AppConfig): AppConfig;

package/dist/helpers/defineConfig.js

@@ -0,0 +1,19 @@
+/**
+ * Helper function to define your application configuration.
+ * Provides autocompletion and type-checking for contentstorage.config.js files.
+ */
+export function defineConfig(config) {
+    // You can add basic runtime validation here if desired,
+    // e.g., check if contentUrl is a valid URL format,
+    // or if languageCodes is not empty.
+    if (!config.languageCodes || config.languageCodes.length === 0) {
+        console.warn('Warning: languageCodes array is empty or missing in the configuration.');
+    }
+    if (!config.contentDir) {
+        // This would typically be a hard error, but defineConfig is more for type safety at edit time.
+        // Runtime validation (see point 3) is better for hard errors.
+        console.warn('Warning: contentDir is missing in the configuration.');
+    }
+    // ... other checks
+    return config;
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -1 +1,2 @@
-export {};
+import { defineConfig } from './helpers/defineConfig.js';
+export { defineConfig };

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,8 +1,9 @@
 import path from 'path';
 import fs from 'fs';
 const DEFAULT_CONFIG = {
-    contentDir: path.join('src', 'assets', 'content'),
-    typesOutputFile: path.join('src', 'generated', 'content-types.ts'),
+    languageCodes: [],
+    contentDir: path.join('src', 'content', 'json'),
+    typesOutputFile: path.join('src', 'content', 'content-types.ts'),
 };
 export async function loadConfig() {
     const configPath = path.resolve(process.cwd(), 'contentstorage.config.js'); // Look in user's current working dir
@@ -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,57 +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}`));
-        // Check if jsonData is a single, non-null object (and not an array)
-        if (typeof jsonData !== 'object' || Array.isArray(jsonData)) {
-            console.log(chalk.red(`Expected a single JSON object from ${config.contentUrl}, but received type ${Array.isArray(jsonData) ? 'array' : typeof jsonData}. Cannot save the file.`));
-            return;
-        }
-        console.log(chalk.green(`Received JSON. Saving it to ${config.contentDir}`));
-        // Determine filename for the single object.
-        // Use 'id' or 'slug' from the object if available, otherwise use 'data' as a fallback base name.
-        const objectData = jsonData; // Use type assertion to access potential properties
-        const baseFilename = objectData.id || objectData.slug || 'data';
-        const filename = `${baseFilename}.json`;
-        const outputPath = path.join(config.contentDir, filename);
-        console.log(chalk.gray(`Received a single JSON object. Attempting to save as ${filename}...`));
-        try {
-            // Ensure the output directory exists
-            await fs.mkdir(config.contentDir, { recursive: true });
-            // Write the single JSON object to the file
-            await fs.writeFile(outputPath, JSON.stringify(jsonData, null, 2));
-            console.log(chalk.green(`Successfully saved the object to ${outputPath}`));
+        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
         }
-        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)}`));
+        // 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 {
+                // 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}`));
             }
-            else {
-                console.error(chalk.red(error.message));
+            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;
             }
-            process.exit(1); // Exit with error code
         }
+        console.log(chalk.green('\nAll content successfully pulled and saved.'));
     }
-    catch (error) {
-        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.8",
+  "version": "0.3.10",
   "type": "module",
   "description": "Fetch content from contentstorage and generate TypeScript types",
   "module": "dist/index.js",