@contentstorage/core 0.3.15 → 0.3.16

package/dist/helpers/flattenJson.d.ts

@@ -0,0 +1 @@
+export declare function flattenJson(data: any, prefix?: string, result?: Record<string, any>): Record<string, any>;

package/dist/helpers/flattenJson.js

@@ -0,0 +1,36 @@
+export function flattenJson(data, prefix = '', result = {}) {
+    if (typeof data === 'object' && data !== null) {
+        if (Array.isArray(data)) {
+            if (data.length === 0 && prefix) {
+                // Handle empty arrays if prefix exists
+                result[prefix] = [];
+            }
+            data.forEach((item, index) => {
+                flattenJson(item, prefix ? `${prefix}.${index}` : `${index}`, result);
+            });
+        }
+        else {
+            // It's an object
+            let isEmptyObject = true;
+            for (const key in data) {
+                if (Object.prototype.hasOwnProperty.call(data, key)) {
+                    isEmptyObject = false;
+                    const newPrefix = prefix ? `${prefix}.${key}` : key;
+                    flattenJson(data[key], newPrefix, result);
+                }
+            }
+            if (isEmptyObject && prefix) {
+                // Handle empty objects if prefix exists
+                result[prefix] = {};
+            }
+        }
+    }
+    else if (prefix) {
+        // Primitive value (string, number, boolean, null)
+        result[prefix] = data;
+    }
+    // If the initial data itself is a primitive and prefix is empty, it means we can't flatten it into key-value pairs.
+    // This function is designed to take a root object or array.
+    // If the root `data` is a primitive, `result` would remain empty, which is fine; `pullContent` should validate the root.
+    return result;
+}

package/dist/scripts/generate-types.js

@@ -2,76 +2,132 @@
 // ^ Shebang ensures the script is executed with Node.js
 import fs from 'fs/promises';
 import path from 'path';
+import axios from 'axios';
 import jsonToTS from 'json-to-ts'; // Import the library
 import chalk from 'chalk'; // Optional: for colored output
 import { loadConfig } from '../lib/configLoader.js';
+import { flattenJson } from '../helpers/flattenJson.js';
 export async function generateTypes() {
     console.log(chalk.blue('Starting type generation...'));
-    const config = await loadConfig(); // Ensure loadConfig provides languageCodes
-    console.log(chalk.gray(`Content will be read from directory: ${config.contentDir}`));
-    console.log(chalk.gray(`Saving TypeScript types to: ${config.typesOutputFile}`));
+    const config = await loadConfig();
+    if (!config.typesOutputFile) {
+        console.error(chalk.red.bold("Configuration error: 'typesOutputFile' is missing."));
+        process.exit(1);
+    }
+    if (!config.languageCodes ||
+        !Array.isArray(config.languageCodes) ||
+        config.languageCodes.length === 0) {
+        console.error(chalk.red.bold("Configuration error: 'languageCodes' must be a non-empty array."));
+        process.exit(1);
+    }
+    console.log(chalk.gray(`TypeScript types will be saved to: ${config.typesOutputFile}`));
+    let jsonObject; // To hold the JSON data from either local or remote source
+    let dataSourceDescription = ''; // For clearer logging
+    const firstLanguageCode = config.languageCodes[0];
     try {
-        // Validate languageCodes from config
-        if (!config.languageCodes ||
-            !Array.isArray(config.languageCodes) ||
-            config.languageCodes.length === 0) {
-            throw new Error('config.languageCodes is missing, not an array, or empty. Cannot determine which JSON file to use for type generation.');
+        let attemptLocalLoad = false;
+        if (config.contentDir) {
+            try {
+                await fs.stat(config.contentDir); // Check if directory exists
+                attemptLocalLoad = true;
+                console.log(chalk.gray(`Local content directory found: ${config.contentDir}`));
+            }
+            catch (statError) {
+                if (statError.code === 'ENOENT') {
+                    console.log(chalk.yellow(`Local content directory specified but not found: ${config.contentDir}. Will attempt to fetch from URL.`));
+                    // attemptLocalLoad remains false
+                }
+                else {
+                    // Other errors accessing contentDir (e.g., permissions)
+                    throw new Error(`Error accessing content directory ${config.contentDir}: ${statError.message}`);
+                }
+            }
         }
-        const firstLanguageCode = config.languageCodes[0];
-        const targetFilename = `${firstLanguageCode}.json`;
-        const jsonFilePath = path.join(config.contentDir, targetFilename);
-        console.log(chalk.gray(`Attempting to generate types using the JSON file for the first configured language code ('${firstLanguageCode}').`));
-        console.log(chalk.gray(`Target file: ${jsonFilePath}`));
-        // Read the specific JSON file
-        let jsonContent;
-        try {
-            jsonContent = await fs.readFile(jsonFilePath, 'utf-8');
+        else {
+            console.log(chalk.yellow(`Local content directory (config.contentDir) not specified. Attempting to fetch from URL.`));
         }
-        catch (err) {
-            if (err.code === 'ENOENT') {
-                throw new Error(`Target JSON file not found: ${jsonFilePath}. Ensure content for language code '${firstLanguageCode}' has been pulled and exists at this location.`);
+        if (attemptLocalLoad && config.contentDir) {
+            // --- Load from local file system ---
+            const targetFilename = `${firstLanguageCode}.json`;
+            const jsonFilePath = path.join(config.contentDir, targetFilename);
+            dataSourceDescription = `local file (${jsonFilePath})`;
+            console.log(chalk.gray(`Attempting to read JSON from: ${jsonFilePath}`));
+            try {
+                const jsonContentString = await fs.readFile(jsonFilePath, 'utf-8');
+                console.log(chalk.gray('Parsing JSON'));
+                const parsendJsonObject = JSON.parse(jsonContentString);
+                console.log(chalk.gray('Flattening JSON for type generation'));
+                jsonObject = flattenJson(parsendJsonObject);
+                console.log(chalk.green(`Successfully read and parsed JSON from ${jsonFilePath}.`));
+            }
+            catch (fileError) {
+                if (fileError.code === 'ENOENT') {
+                    throw new Error(`Target JSON file not found at ${jsonFilePath}. ` +
+                        `Ensure content for language code '${firstLanguageCode}' has been pulled and exists locally, ` +
+                        `or ensure 'contentDir' is not set if you intend to fetch from URL.`);
+                }
+                throw new Error(`Failed to read or parse JSON from ${jsonFilePath}: ${fileError.message}`);
             }
-            // Re-throw other fs.readFile errors (e.g., permission issues)
-            throw new Error(`Failed to read file ${jsonFilePath}: ${err.message}`);
         }
-        // Parse the JSON content
-        let jsonObject;
-        try {
-            jsonObject = JSON.parse(jsonContent);
+        else {
+            // --- Fetch from URL ---
+            if (!config.contentUrl) {
+                throw new Error("Cannot generate types: 'contentDir' is not accessible or not specified, and 'contentUrl' is also missing in configuration.");
+            }
+            const fileUrl = `${config.contentUrl}/${firstLanguageCode}.json`; // Adjust URL construction if necessary
+            dataSourceDescription = `remote URL (${fileUrl})`;
+            console.log(chalk.gray(`Attempting to fetch JSON from: ${fileUrl}`));
+            try {
+                const response = await axios.get(fileUrl, { responseType: 'json' });
+                const jsonResponse = response.data;
+                console.log(chalk.gray('Flattening JSON for type generation'));
+                jsonObject = flattenJson(jsonResponse);
+                if (typeof jsonObject !== 'object' || jsonObject === null) {
+                    throw new Error(`Workspaceed data from ${fileUrl} is not a valid JSON object. Received type: ${typeof jsonObject}`);
+                }
+                console.log(chalk.green(`Successfully fetched and parsed JSON from ${fileUrl}. This content will not be saved locally.`));
+            }
+            catch (fetchError) {
+                let errorDetail = fetchError.message;
+                if (axios.isAxiosError(fetchError)) {
+                    errorDetail = `Status: ${fetchError.response?.status}, Response: ${JSON.stringify(fetchError.response?.data)}`;
+                }
+                throw new Error(`Failed to fetch JSON from ${fileUrl}: ${errorDetail}`);
+            }
         }
-        catch (parseError) {
-            throw new Error(`Failed to parse JSON from file ${targetFilename}: ${parseError.message}`);
+        // Validate the obtained jsonObject (must be an object or array for json-to-ts)
+        if (typeof jsonObject !== 'object' || jsonObject === null) {
+            // jsonToTS can handle root arrays too, but if it's primitive it's an issue.
+            // Allowing arrays here explicitly based on jsonToTS capability.
+            if (!Array.isArray(jsonObject)) {
+                throw new Error(`The content obtained from ${dataSourceDescription} is not a JSON object or array (type: ${typeof jsonObject}). Cannot generate types.`);
+            }
         }
         // Generate TypeScript interfaces using json-to-ts
-        // The root type name for the generated interface. You might want to make this configurable.
-        const rootTypeName = 'ContentRoot';
+        const rootTypeName = 'ContentRoot'; // As per your previous update
+        console.log(chalk.gray(`Generating TypeScript types with root name '${rootTypeName}'...`));
         const typeDeclarations = jsonToTS.default(jsonObject, {
             rootName: rootTypeName,
         });
-        // If your previous code `jsonToTS.default(...)` was correct for your setup,
-        // please revert the line above to:
-        // const typeDeclarations: string[] = jsonToTS.default(jsonObject, {
-        //   rootName: rootTypeName,
-        // });
         if (!typeDeclarations || typeDeclarations.length === 0) {
-            throw new Error(`Could not generate types from ${targetFilename}. The file might be empty, malformed, or not produce any types.`);
+            throw new Error(`Could not generate types from the content of ${dataSourceDescription}. 'json-to-ts' returned no declarations.`);
         }
-        const outputContent = typeDeclarations.join('\n\n'); // Add extra newline between interfaces for readability
-        // Ensure the output directory exists
+        const outputContent = typeDeclarations.join('\n\n');
+        // Ensure the output directory exists for the types file
         const outputDir = path.dirname(config.typesOutputFile);
         await fs.mkdir(outputDir, { recursive: true });
         // Write the generated types to the output file
         await fs.writeFile(config.typesOutputFile, outputContent, 'utf-8');
-        console.log(chalk.green(`TypeScript types generated successfully at ${config.typesOutputFile}`));
+        console.log(chalk.green(`TypeScript types generated successfully at ${config.typesOutputFile} using data from ${dataSourceDescription}.`));
     }
     catch (error) {
         console.error(chalk.red.bold('\nError generating TypeScript types:'));
         console.error(chalk.red(error.message));
-        // It's good practice to log the stack for unexpected errors if not already done by a higher-level handler
-        // if (error.stack) {
+        // Optionally log stack for more details during development
+        // if (error.stack && process.env.NODE_ENV === 'development') {
         //   console.error(chalk.gray(error.stack));
         // }
-        process.exit(1); // Exit with error code
+        process.exit(1);
     }
 }
 generateTypes();

package/dist/scripts/pull-content.js

@@ -43,6 +43,9 @@ export async function pullContent() {
                     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 and json for ${languageCode}. Saving to ${outputPath}`));
+                await fs.writeFile(outputPath, JSON.stringify(jsonData, null, 2));
+                console.log(chalk.green(`Successfully saved ${outputPath}`));
                 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));

package/package.json

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