@contentstorage/core 2.1.1 → 2.2.1

package/dist/scripts/generate-types.js

@@ -1,174 +0,0 @@
-#!/usr/bin/env node
-// ^ Ensures the script is executed with Node.js
-import fs from 'fs/promises';
-import path from 'path';
-import axios from 'axios';
-import chalk from 'chalk'; // Optional: for colored output
-import { loadConfig } from '../lib/configLoader.js';
-import { flattenJson } from '../helpers/flattenJson.js';
-import { CONTENTSTORAGE_CONFIG } from '../contentstorage-config.js';
-import { jsonToTS } from '../type-generation/index.js';
-export async function generateTypes() {
-    console.log(chalk.blue('Starting type generation...'));
-    const args = process.argv.slice(2);
-    const cliConfig = {};
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (arg.startsWith('--')) {
-            const key = arg.substring(2);
-            const value = args[i + 1];
-            if (key === 'pending-changes') {
-                cliConfig.pendingChanges = true;
-            }
-            else if (value && !value.startsWith('--')) {
-                if (key === 'lang') {
-                    cliConfig.languageCodes = [value.toUpperCase()];
-                }
-                else if (key === 'content-key') {
-                    cliConfig.contentKey = value;
-                }
-                else if (key === 'output') {
-                    cliConfig.typesOutputFile = value;
-                }
-                // Skip the value in the next iteration
-                i++;
-            }
-        }
-    }
-    let fileConfig = {};
-    try {
-        fileConfig = await loadConfig();
-    }
-    catch {
-        console.log(chalk.yellow('Could not load a configuration file. Proceeding with CLI arguments.'));
-    }
-    const config = { ...fileConfig, ...cliConfig };
-    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.blue(`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 {
-        let attemptLocalLoad = false;
-        if (config.contentDir) {
-            try {
-                await fs.stat(config.contentDir); // Check if directory exists
-                attemptLocalLoad = true;
-                console.log(chalk.blue(`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}`);
-                }
-            }
-        }
-        else {
-            console.log(chalk.yellow(`Local content directory (config.contentDir) not specified. Attempting to fetch from URL.`));
-        }
-        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.blue(`Attempting to read JSON from: ${jsonFilePath}`));
-            try {
-                const jsonContentString = await fs.readFile(jsonFilePath, 'utf-8');
-                console.log(chalk.blue('Parsing JSON'));
-                const parsendJsonObject = JSON.parse(jsonContentString);
-                console.log(chalk.blue('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}`);
-            }
-        }
-        else {
-            if (!config.contentKey) {
-                throw new Error('Cannot generate types: contentKey is missing');
-            }
-            let fileUrl;
-            const requestConfig = { responseType: 'json' };
-            if (config.pendingChanges) {
-                fileUrl = `${CONTENTSTORAGE_CONFIG.API_URL}/pending-changes/get-json?languageCode=${firstLanguageCode}`;
-                requestConfig.headers = {
-                    'X-Content-Key': config.contentKey,
-                };
-            }
-            else {
-                fileUrl = `${CONTENTSTORAGE_CONFIG.BASE_URL}/${config.contentKey}/content/${firstLanguageCode}.json`;
-            }
-            dataSourceDescription = `remote URL (${fileUrl})`;
-            console.log(chalk.blue(`Attempting to fetch JSON from: ${fileUrl}`));
-            try {
-                const response = await axios.get(fileUrl, requestConfig);
-                let jsonResponse = response.data;
-                // Handle API response structure - API returns { data: actualContent }
-                if (config.pendingChanges && jsonResponse && typeof jsonResponse === 'object' && 'data' in jsonResponse) {
-                    jsonResponse = jsonResponse.data;
-                }
-                console.log(chalk.blue('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}`);
-            }
-        }
-        // 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
-        const rootTypeName = 'ContentRoot';
-        console.log(chalk.blue(`Generating TypeScript types with root name '${rootTypeName}'...`));
-        const typeDeclarations = jsonToTS(jsonObject, {
-            rootName: rootTypeName,
-        });
-        if (!typeDeclarations || typeDeclarations.length === 0) {
-            throw new Error(`Could not generate types from the content of ${dataSourceDescription}. 'json-to-ts' returned no declarations.`);
-        }
-        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} using data from ${dataSourceDescription}.`));
-    }
-    catch (error) {
-        console.error(chalk.red.bold('\nError generating TypeScript types:'));
-        console.error(chalk.red(error.message));
-        process.exit(1);
-    }
-}

package/dist/scripts/pull-content.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export declare function pullContent(): Promise<void>;

package/dist/scripts/pull-content.js

@@ -1,137 +0,0 @@
-#!/usr/bin/env node
-import axios from 'axios';
-import fs from 'fs/promises';
-import path from 'path';
-import chalk from 'chalk';
-import { loadConfig } from '../lib/configLoader.js';
-import { CONTENTSTORAGE_CONFIG } from '../contentstorage-config.js';
-export async function pullContent() {
-    console.log(chalk.blue('Starting content pull...'));
-    const args = process.argv.slice(2);
-    const cliConfig = {};
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (arg.startsWith('--')) {
-            const key = arg.substring(2);
-            const value = args[i + 1];
-            if (key === 'pending-changes') {
-                cliConfig.pendingChanges = true;
-            }
-            else if (value && !value.startsWith('--')) {
-                if (key === 'lang') {
-                    cliConfig.languageCodes = [value.toUpperCase()];
-                }
-                else if (key === 'content-key') {
-                    cliConfig.contentKey = value;
-                }
-                else if (key === 'content-dir') {
-                    cliConfig.contentDir = value;
-                }
-                // Skip the value in the next iteration
-                i++;
-            }
-        }
-    }
-    let fileConfig = {};
-    try {
-        fileConfig = await loadConfig();
-    }
-    catch {
-        console.log(chalk.yellow('Could not load a configuration file. Proceeding with CLI arguments.'));
-    }
-    const config = { ...fileConfig, ...cliConfig };
-    // Validate required fields
-    if (!config.contentKey) {
-        console.error(chalk.red('Error: Configuration is missing the required "contentKey" property.'));
-        process.exit(1);
-    }
-    if (!config.contentDir) {
-        console.error(chalk.red('Error: Configuration is missing the required "contentDir" property.'));
-        process.exit(1);
-    }
-    console.log(chalk.blue(`Content key: ${config.contentKey}`));
-    console.log(chalk.blue(`Saving content to: ${config.contentDir}`));
-    try {
-        // 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
-        }
-        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
-        }
-        // 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) {
-            let fileUrl;
-            const requestConfig = {};
-            if (config.pendingChanges) {
-                fileUrl = `${CONTENTSTORAGE_CONFIG.API_URL}/pending-changes/get-json?languageCode=${languageCode}`;
-                requestConfig.headers = {
-                    'X-Content-Key': config.contentKey
-                };
-            }
-            else {
-                fileUrl = `${CONTENTSTORAGE_CONFIG.BASE_URL}/${config.contentKey}/content/${languageCode}.json`;
-            }
-            const filename = `${languageCode}.json`;
-            const outputPath = path.join(config.contentDir, filename);
-            console.log(chalk.blue(`\nProcessing language: ${languageCode}`));
-            console.log(chalk.blue(`Using following contentKey to fetch json: ${config.contentKey}`));
-            try {
-                // Fetch data for the current language
-                const response = await axios.get(fileUrl, requestConfig);
-                let jsonData = response.data;
-                // Handle API response structure - only for pending changes API
-                if (config.pendingChanges && jsonData && typeof jsonData === 'object' && 'data' in jsonData) {
-                    jsonData = jsonData.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}`));
-                await fs.writeFile(outputPath, JSON.stringify(jsonData, null, 2));
-                console.log(chalk.green(`Successfully saved ${outputPath}`));
-            }
-            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('\nAll content successfully pulled and saved.'));
-    }
-    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
-    }
-}