@teleporthq/teleport-plugin-next-data-source 0.40.15

package/dist/esm/utils.js

@@ -0,0 +1,722 @@
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { FileType, ChunkType, } from '@teleporthq/teleport-types';
+import * as types from '@babel/types';
+import { ASTUtils } from '@teleporthq/teleport-plugin-common';
+import { StringUtils } from '@teleporthq/teleport-shared';
+import { generateDataSourceFetcherWithCore } from './data-source-fetchers';
+var VALID_DATA_SOURCE_TYPES = [
+    'rest-api',
+    'postgresql',
+    'mysql',
+    'mariadb',
+    'amazon-redshift',
+    'mongodb',
+    'cockroachdb',
+    'tidb',
+    'redis',
+    'firestore',
+    'clickhouse',
+    'airtable',
+    'supabase',
+    'turso',
+    'javascript',
+    'google-sheets',
+    'csv-file',
+    'static-collection',
+];
+export var sanitizeFileName = function (input) {
+    if (!input || typeof input !== 'string') {
+        return 'unknown';
+    }
+    return (input
+        // Remove path traversal attempts
+        .replace(/\.\./g, '')
+        .replace(/[\/\\]/g, '-')
+        // Remove invalid filename characters
+        .replace(/[<>:"|?*\x00-\x1F]/g, '')
+        // Replace spaces with dashes
+        .replace(/\s+/g, '-')
+        // Remove leading/trailing dashes and dots
+        .replace(/^[-_.]+|[-_.]+$/g, '')
+        // Limit length to prevent filesystem issues
+        .substring(0, 200) || 'unknown');
+};
+export var isNonEmptyString = function (value) {
+    return typeof value === 'string' && value.trim().length > 0;
+};
+export var hoistLoadingFromRepeater = function (dataSourceNode) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    if (!dataSourceNode || !dataSourceNode.content) {
+        return;
+    }
+    var children = dataSourceNode.children || [];
+    for (var _i = 0, children_1 = children; _i < children_1.length; _i++) {
+        var child = children_1[_i];
+        if (child.type === 'cms-list-repeater' && ((_b = (_a = child.content) === null || _a === void 0 ? void 0 : _a.nodes) === null || _b === void 0 ? void 0 : _b.loading)) {
+            if (!dataSourceNode.content.nodes) {
+                dataSourceNode.content.nodes = {};
+            }
+            if (!dataSourceNode.content.nodes.loading &&
+                ((_d = (_c = child.content.nodes.loading.content) === null || _c === void 0 ? void 0 : _c.children) === null || _d === void 0 ? void 0 : _d.length) > 0) {
+                dataSourceNode.content.nodes.loading = child.content.nodes.loading;
+            }
+            break;
+        }
+    }
+    if ((_g = (_f = (_e = dataSourceNode.content.nodes) === null || _e === void 0 ? void 0 : _e.success) === null || _f === void 0 ? void 0 : _f.content) === null || _g === void 0 ? void 0 : _g.children) {
+        for (var _m = 0, _o = dataSourceNode.content.nodes.success.content.children; _m < _o.length; _m++) {
+            var child = _o[_m];
+            if (child.type === 'cms-list-repeater' && ((_j = (_h = child.content) === null || _h === void 0 ? void 0 : _h.nodes) === null || _j === void 0 ? void 0 : _j.loading)) {
+                if (!dataSourceNode.content.nodes.loading &&
+                    ((_l = (_k = child.content.nodes.loading.content) === null || _k === void 0 ? void 0 : _k.children) === null || _l === void 0 ? void 0 : _l.length) > 0) {
+                    dataSourceNode.content.nodes.loading = child.content.nodes.loading;
+                }
+                break;
+            }
+        }
+    }
+};
+// tslint:disable-next-line:no-any
+export var validateResourceDefinition = function (resourceDefinition) {
+    if (!resourceDefinition || typeof resourceDefinition !== 'object') {
+        return { isValid: false, error: 'Resource definition is missing or invalid' };
+    }
+    var dataSourceId = resourceDefinition.dataSourceId, tableName = resourceDefinition.tableName, dataSourceType = resourceDefinition.dataSourceType;
+    if (!isNonEmptyString(dataSourceId)) {
+        return { isValid: false, error: 'Data source ID is missing or invalid' };
+    }
+    if (!isNonEmptyString(dataSourceType)) {
+        return { isValid: false, error: 'Data source type is missing or invalid' };
+    }
+    if (!VALID_DATA_SOURCE_TYPES.includes(dataSourceType)) {
+        return { isValid: false, error: "Invalid data source type: ".concat(dataSourceType) };
+    }
+    // tableName is optional for some data sources (like REST API, JavaScript, etc.)
+    if (tableName !== undefined && !isNonEmptyString(tableName)) {
+        return { isValid: false, error: 'Table name must be a non-empty string when provided' };
+    }
+    return { isValid: true };
+};
+// tslint:disable-next-line:no-any
+export var validateNodeContent = function (content) {
+    if (!content || typeof content !== 'object') {
+        return { isValid: false, error: 'Node content is missing or invalid' };
+    }
+    if (!content.resourceDefinition) {
+        return { isValid: false, error: 'Resource definition is missing from node content' };
+    }
+    // key is optional - we can generate one from the resource definition if missing
+    return { isValid: true };
+};
+export var validateDataSourceConfig = function (dataSource) {
+    if (!dataSource || typeof dataSource !== 'object') {
+        return { isValid: false, error: 'Data source is missing or invalid' };
+    }
+    if (!isNonEmptyString(dataSource.id)) {
+        return { isValid: false, error: 'Data source ID is missing' };
+    }
+    if (!isNonEmptyString(dataSource.type)) {
+        return { isValid: false, error: 'Data source type is missing' };
+    }
+    if (!dataSource.config || typeof dataSource.config !== 'object') {
+        return { isValid: false, error: 'Data source config is missing or invalid' };
+    }
+    return { isValid: true };
+};
+export var generateSafeFileName = function (dataSourceType, tableName, dataSourceId) {
+    var sanitizedType = sanitizeFileName(dataSourceType);
+    var sanitizedTable = sanitizeFileName(tableName || 'data');
+    var sanitizedId = sanitizeFileName(dataSourceId);
+    // Create a unique identifier using parts of the dataSourceId
+    var shortId = sanitizedId.substring(0, 8);
+    var baseName = "".concat(sanitizedType, "-").concat(sanitizedTable, "-").concat(shortId);
+    return StringUtils.camelCaseToDashCase(baseName);
+};
+export var extractDataSourceIntoNextAPIFolder = function (node, dataSources, componentChunk, extractedResources) {
+    var _a, _b, _c;
+    try {
+        // Validate node content structure
+        var contentValidation = validateNodeContent(node.content);
+        if (!contentValidation.isValid) {
+            return;
+        }
+        var resourceDefinition = node.content.resourceDefinition;
+        // Validate resource definition
+        var resourceValidation = validateResourceDefinition(resourceDefinition);
+        if (!resourceValidation.isValid) {
+            return;
+        }
+        var dataSourceId = resourceDefinition.dataSourceId, tableName = resourceDefinition.tableName, dataSourceType = resourceDefinition.dataSourceType;
+        // Check if dataSources object exists
+        if (!dataSources || typeof dataSources !== 'object') {
+            return;
+        }
+        // Check if data source exists
+        var dataSource = dataSources[dataSourceId];
+        if (!dataSource) {
+            return;
+        }
+        // Validate data source configuration
+        var configValidation = validateDataSourceConfig(dataSource);
+        if (!configValidation.isValid) {
+            return;
+        }
+        // Check if component chunk has meta and nodesLookup
+        if (!componentChunk.meta || !componentChunk.meta.nodesLookup) {
+            return;
+        }
+        // Generate safe file name
+        var fileName = generateSafeFileName(dataSourceType, tableName || 'data', dataSourceId);
+        // Check if file name is valid
+        if (!fileName || fileName === 'unknown') {
+            return;
+        }
+        // Find JSX node by searching through nodesLookup
+        // The JSX generator creates keys like: ds-{dataSourceId}-{timestamp}
+        // We need to find the node that matches our resourceDefinition
+        // IMPORTANT: Match by both dataSourceId AND renderPropIdentifier to handle multiple DataProviders with same data source
+        var jsxNode = null;
+        var targetRenderProp = (_a = node.content) === null || _a === void 0 ? void 0 : _a.renderPropIdentifier;
+        // tslint:disable-next-line:no-any
+        for (var _i = 0, _d = Object.values(componentChunk.meta.nodesLookup); _i < _d.length; _i++) {
+            var jsxElement = _d[_i];
+            // tslint:disable-next-line:no-any
+            if (jsxElement.type === 'JSXElement') {
+                var attrs = jsxElement.openingElement.attributes;
+                // Look for resourceDefinition attribute
+                // tslint:disable-next-line:no-any
+                var resourceDefAttr = attrs.find(function (attr) {
+                    return attr.type === 'JSXAttribute' &&
+                        attr.name.name === 'resourceDefinition';
+                });
+                // Look for name attribute to match with renderPropIdentifier
+                // tslint:disable-next-line:no-any
+                var nameAttr = attrs.find(function (attr) {
+                    return attr.type === 'JSXAttribute' &&
+                        attr.name.name === 'name';
+                });
+                if (resourceDefAttr &&
+                    resourceDefAttr.value &&
+                    resourceDefAttr.value.type === 'JSXExpressionContainer') {
+                    var expr = resourceDefAttr.value.expression;
+                    if (expr.type === 'ObjectExpression') {
+                        // Check if this matches our resourceDefinition
+                        var props = expr.properties;
+                        // tslint:disable-next-line:no-any
+                        var idProp = props.find(function (p) { var _a; return ((_a = p.key) === null || _a === void 0 ? void 0 : _a.value) === 'dataSourceId'; });
+                        // tslint:disable-next-line:no-any
+                        var idValue = (_b = idProp === null || idProp === void 0 ? void 0 : idProp.value) === null || _b === void 0 ? void 0 : _b.value;
+                        // Match by dataSourceId
+                        var dataSourceMatches = idValue === dataSourceId;
+                        // Also check name prop matches renderPropIdentifier
+                        var renderPropMatches = !targetRenderProp; // If no targetRenderProp, don't check it
+                        if (targetRenderProp && nameAttr && nameAttr.value) {
+                            // The name attribute value is usually a StringLiteral or JSXExpressionContainer
+                            if (nameAttr.value.type === 'StringLiteral') {
+                                if (nameAttr.value.value === targetRenderProp) {
+                                    renderPropMatches = true;
+                                }
+                            }
+                            else if (nameAttr.value.type === 'JSXExpressionContainer') {
+                                var nameExpr = nameAttr.value.expression;
+                                if (nameExpr.type === 'StringLiteral' && nameExpr.value === targetRenderProp) {
+                                    renderPropMatches = true;
+                                }
+                            }
+                        }
+                        // Before matching, check if this node already has fetchData - if so, skip it
+                        // This is crucial for handling multiple DataProviders with same dataSourceId and name
+                        var alreadyHasFetchData = attrs.some(function (attr) { var _a; return ((_a = attr.name) === null || _a === void 0 ? void 0 : _a.name) === 'fetchData'; });
+                        if (dataSourceMatches && renderPropMatches && !alreadyHasFetchData) {
+                            jsxNode = jsxElement;
+                            break;
+                        }
+                        else if (dataSourceMatches && renderPropMatches && alreadyHasFetchData) {
+                            // Continue searching for the next matching node without fetchData
+                        }
+                    }
+                }
+            }
+        }
+        if (!jsxNode || jsxNode.type !== 'JSXElement') {
+            return;
+        }
+        // Ensure opening element and attributes exist
+        if (!jsxNode.openingElement || !Array.isArray(jsxNode.openingElement.attributes)) {
+            return;
+        }
+        // Check if this node has already been processed (has fetchData attribute)
+        var existingFetchData = jsxNode.openingElement.attributes.find(function (attr) { var _a; return ((_a = attr.name) === null || _a === void 0 ? void 0 : _a.name) === 'fetchData'; });
+        if (existingFetchData) {
+            return;
+        }
+        // Check if there are resource params
+        var resourceParams = ((_c = node.content.resource) === null || _c === void 0 ? void 0 : _c.params) || {};
+        var hasParams = Object.keys(resourceParams).length > 0;
+        // Build resource path - use template literal if params exist
+        var resourcePath = void 0;
+        if (hasParams) {
+            resourcePath = types.templateLiteral([
+                types.templateElement({ raw: "/api/".concat(fileName, "?"), cooked: "/api/".concat(fileName, "?") }),
+                types.templateElement({ raw: '', cooked: '' }),
+            ], [types.newExpression(types.identifier('URLSearchParams'), [types.identifier('params')])]);
+        }
+        else {
+            resourcePath = types.stringLiteral("/api/".concat(fileName));
+        }
+        var fetchAST = types.callExpression(types.memberExpression(types.callExpression(types.identifier('fetch'), [
+            resourcePath,
+            types.objectExpression([
+                types.objectProperty(types.identifier('headers'), types.objectExpression([
+                    types.objectProperty(types.stringLiteral('Content-Type'), types.stringLiteral('application/json')),
+                ])),
+            ]),
+        ]), types.identifier('then')), [
+            types.arrowFunctionExpression([types.identifier('res')], types.callExpression(types.memberExpression(types.identifier('res'), types.identifier('json')), [])),
+        ]);
+        var dataExpression = ASTUtils.generateMemberExpressionASTFromPath([
+            'response',
+            'data',
+        ]);
+        // If there are params, the arrow function should accept params
+        var resourceAST = types.arrowFunctionExpression(hasParams ? [types.identifier('params')] : [], types.callExpression(types.memberExpression(fetchAST, types.identifier('then'), false), [
+            types.arrowFunctionExpression([types.identifier('response')], dataExpression),
+        ]));
+        jsxNode.openingElement.attributes.unshift(types.jSXAttribute(types.jsxIdentifier('fetchData'), types.jsxExpressionContainer(resourceAST)));
+        var hasPersistDataAttr = jsxNode.openingElement.attributes.some(function (attr) {
+            var _a;
+            return attr.type === 'JSXAttribute' &&
+                ((_a = attr.name) === null || _a === void 0 ? void 0 : _a.name) === 'persistDataDuringLoading';
+        });
+        if (!hasPersistDataAttr) {
+            jsxNode.openingElement.attributes.push(types.jsxAttribute(types.jsxIdentifier('persistDataDuringLoading'), types.jsxExpressionContainer(types.booleanLiteral(true))));
+        }
+        // Ensure extracted resources object exists
+        if (!extractedResources || typeof extractedResources !== 'object') {
+            return;
+        }
+        // Check if a utils file already exists for this data source (from getStaticProps)
+        // If so, create an API route that re-exports handler from it to avoid code duplication
+        if (extractedResources["utils/".concat(fileName)]) {
+            var apiRouteCode = "import dataSourceModule from '../../utils/data-sources/".concat(fileName, "'\n\nexport default dataSourceModule.handler\n");
+            extractedResources["api/".concat(fileName)] = {
+                fileName: fileName,
+                fileType: FileType.JS,
+                path: ['pages', 'api'],
+                content: apiRouteCode,
+            };
+            return;
+        }
+        // Generate fetcher code with BOTH fetchData and handler
+        var fetcherCode = void 0;
+        try {
+            fetcherCode = generateDataSourceFetcherWithCore(dataSource, tableName || '');
+        }
+        catch (error) {
+            return;
+        }
+        extractedResources["api/".concat(fileName)] = {
+            fileName: fileName,
+            fileType: FileType.JS,
+            path: ['pages', 'api'],
+            content: fetcherCode,
+        };
+    }
+    catch (error) {
+        // Catch any unexpected errors to prevent plugin from crashing
+    }
+};
+export var isEmbeddedDataSource = function (dataSourceType) {
+    return ['javascript', 'csv-file', 'static-collection'].includes(dataSourceType);
+};
+export var replaceSecretReference = function (value, options) {
+    if (options === void 0) { options = {}; }
+    var _a = options.templateLiteral, templateLiteral = _a === void 0 ? false : _a;
+    // Handle null and undefined
+    if (value === null) {
+        return 'null';
+    }
+    if (value === undefined) {
+        return 'undefined';
+    }
+    // Handle non-string values
+    if (typeof value !== 'string') {
+        try {
+            return JSON.stringify(value);
+        }
+        catch (error) {
+            // Handle circular references or non-serializable values
+            return 'null';
+        }
+    }
+    // Check if it's a secret reference
+    if (value.startsWith('teleporthq.secrets.')) {
+        var envVar = value.replace('teleporthq.secrets.', '');
+        // Validate environment variable name
+        // Must be alphanumeric, underscores, and start with letter or underscore
+        if (/^[A-Z_][A-Z0-9_]*$/i.test(envVar)) {
+            return templateLiteral ? "${process.env.".concat(envVar, "}") : "process.env.".concat(envVar);
+        }
+        else {
+            // Invalid env var name, use as regular string
+            return JSON.stringify(value);
+        }
+    }
+    // Regular string value
+    try {
+        return JSON.stringify(value);
+    }
+    catch (error) {
+        // Fallback for any serialization issues
+        return '""';
+    }
+};
+export var sanitizeNumericParam = function (value, defaultValue) {
+    if (defaultValue === void 0) { defaultValue = 0; }
+    if (typeof value === 'number' && !isNaN(value) && isFinite(value)) {
+        return Math.max(0, Math.floor(value));
+    }
+    if (typeof value === 'string') {
+        var parsed = parseInt(value, 10);
+        if (!isNaN(parsed) && isFinite(parsed)) {
+            return Math.max(0, parsed);
+        }
+    }
+    return defaultValue;
+};
+export var sanitizePort = function (port, defaultPort) {
+    var sanitized = sanitizeNumericParam(port, defaultPort);
+    // Ensure port is in valid range (1-65535)
+    if (sanitized < 1 || sanitized > 65535) {
+        return defaultPort;
+    }
+    return sanitized;
+};
+export var isValidUrl = function (url) {
+    if (typeof url !== 'string' || !url) {
+        return false;
+    }
+    try {
+        var parsed = new URL(url);
+        // Check for valid protocols
+        return ['http:', 'https:', 'mongodb:', 'redis:', 'postgresql:', 'mysql:'].includes(parsed.protocol);
+    }
+    catch (_a) {
+        return false;
+    }
+};
+export var sanitizeIdentifier = function (identifier) {
+    if (typeof identifier !== 'string' || !identifier) {
+        return '';
+    }
+    // Remove dangerous characters, only allow safe ones
+    return identifier.replace(/[^a-zA-Z0-9_-]/g, '').substring(0, 64);
+};
+// tslint:disable-next-line:no-any
+export var extractDataSourceIntoGetStaticProps = function (node, dataSources, componentChunk, getStaticPropsChunk, chunks, extractedResources, dependencies) {
+    var _a, _b;
+    try {
+        // Validate node content
+        var contentValidation = validateNodeContent(node.content);
+        if (!contentValidation.isValid) {
+            return { success: false };
+        }
+        var resourceDefinition = node.content.resourceDefinition;
+        var resourceValidation = validateResourceDefinition(resourceDefinition);
+        if (!resourceValidation.isValid) {
+            return { success: false };
+        }
+        var dataSourceId_1 = resourceDefinition.dataSourceId, tableName_1 = resourceDefinition.tableName, dataSourceType = resourceDefinition.dataSourceType;
+        if (!dataSources || typeof dataSources !== 'object') {
+            return { success: false };
+        }
+        var dataSource = dataSources[dataSourceId_1];
+        if (!dataSource) {
+            return { success: false };
+        }
+        var configValidation = validateDataSourceConfig(dataSource);
+        if (!configValidation.isValid) {
+            return { success: false };
+        }
+        if (!componentChunk.meta || !componentChunk.meta.nodesLookup) {
+            return { success: false };
+        }
+        // Generate prop key first
+        var sanitizedDsName = StringUtils.dashCaseToCamelCase(sanitizeFileName(dataSource.name || dataSourceId_1));
+        var sanitizedTableName = StringUtils.dashCaseToCamelCase(sanitizeFileName(tableName_1 || 'data'));
+        var propKey_1 = "".concat(sanitizedDsName, "_").concat(sanitizedTableName, "_data");
+        // Find ALL JSX nodes matching this dataSourceId AND tableName and add initialData to ALL of them
+        var matchingJsxNodes_2 = [];
+        // Helper function to recursively traverse the AST and find all matching JSXElements
+        var traverseAST_1 = function (astNode) {
+            var _a, _b;
+            if (!astNode || typeof astNode !== 'object') {
+                return;
+            }
+            if (astNode.type === 'JSXElement') {
+                var jsxElement = astNode;
+                var attrs = jsxElement.openingElement.attributes;
+                var resourceDefAttr = attrs.find(function (attr) {
+                    return attr.type === 'JSXAttribute' &&
+                        attr.name.name === 'resourceDefinition';
+                });
+                if (resourceDefAttr &&
+                    resourceDefAttr.value &&
+                    resourceDefAttr.value.type === 'JSXExpressionContainer') {
+                    var expr = resourceDefAttr.value.expression;
+                    if (expr.type === 'ObjectExpression') {
+                        var props = expr.properties;
+                        // tslint:disable-next-line:no-any
+                        var idProp = props.find(function (p) { var _a; return ((_a = p.key) === null || _a === void 0 ? void 0 : _a.value) === 'dataSourceId'; });
+                        // tslint:disable-next-line:no-any
+                        var idValue = (_a = idProp === null || idProp === void 0 ? void 0 : idProp.value) === null || _a === void 0 ? void 0 : _a.value;
+                        // Also check tableName to ensure we're matching the right data source
+                        // tslint:disable-next-line:no-any
+                        var tableNameProp = props.find(function (p) { var _a; return ((_a = p.key) === null || _a === void 0 ? void 0 : _a.value) === 'tableName'; });
+                        // tslint:disable-next-line:no-any
+                        var tableNameValue = (_b = tableNameProp === null || tableNameProp === void 0 ? void 0 : tableNameProp.value) === null || _b === void 0 ? void 0 : _b.value;
+                        if (idValue === dataSourceId_1 && tableNameValue === tableName_1) {
+                            matchingJsxNodes_2.push(jsxElement);
+                        }
+                    }
+                }
+            }
+            // Recursively traverse all properties
+            for (var key in astNode) {
+                if (astNode.hasOwnProperty(key)) {
+                    var value = astNode[key];
+                    if (Array.isArray(value)) {
+                        value.forEach(function (item) { return traverseAST_1(item); });
+                    }
+                    else if (typeof value === 'object') {
+                        traverseAST_1(value);
+                    }
+                }
+            }
+        };
+        // Traverse the entire component AST content
+        traverseAST_1(componentChunk.content);
+        if (matchingJsxNodes_2.length === 0) {
+            return { success: false };
+        }
+        // Update ALL matching JSX nodes with initialData
+        for (var _i = 0, matchingJsxNodes_1 = matchingJsxNodes_2; _i < matchingJsxNodes_1.length; _i++) {
+            var jsxNode = matchingJsxNodes_1[_i];
+            // For SSR/SSG with initialData, rename 'children' to 'renderSuccess'
+            var childrenAttrIndex = jsxNode.openingElement.attributes.findIndex(function (attr) { var _a; return ((_a = attr.name) === null || _a === void 0 ? void 0 : _a.name) === 'children'; });
+            if (childrenAttrIndex !== -1) {
+                var childrenAttr = jsxNode.openingElement.attributes[childrenAttrIndex];
+                var renderSuccessAttr = types.jsxAttribute(types.jsxIdentifier('renderSuccess'), childrenAttr.value);
+                jsxNode.openingElement.attributes[childrenAttrIndex] = renderSuccessAttr;
+            }
+            // Remove existing initialData and persistDataDuringLoading attributes to avoid duplicates
+            jsxNode.openingElement.attributes = jsxNode.openingElement.attributes.filter(function (attr) {
+                var _a, _b;
+                return ((_a = attr.name) === null || _a === void 0 ? void 0 : _a.name) !== 'initialData' &&
+                    ((_b = attr.name) === null || _b === void 0 ? void 0 : _b.name) !== 'persistDataDuringLoading';
+            });
+            // Add initialData attribute
+            var initialDataAttr = types.jsxAttribute(types.jsxIdentifier('initialData'), types.jsxExpressionContainer(types.memberExpression(types.identifier('props'), types.identifier(propKey_1))));
+            jsxNode.openingElement.attributes.push(initialDataAttr);
+            // Add persistDataDuringLoading={true}
+            var persistDataAttr = types.jsxAttribute(types.jsxIdentifier('persistDataDuringLoading'), types.jsxExpressionContainer(types.booleanLiteral(true)));
+            jsxNode.openingElement.attributes.push(persistDataAttr);
+        }
+        // Generate safe file name for the fetcher
+        var fileName = generateSafeFileName(dataSourceType, tableName_1 || 'data', dataSourceId_1);
+        if (!fileName || fileName === 'unknown') {
+            return { success: false };
+        }
+        // Generate fetcher code with core function
+        var fetcherCode = void 0;
+        try {
+            fetcherCode = generateDataSourceFetcherWithCore(dataSource, tableName_1 || '');
+        }
+        catch (error) {
+            // tslint:disable-next-line:no-console
+            console.error("Failed to generate fetcher for ".concat(dataSourceType, " (").concat(dataSourceId_1, "):"), error);
+            return { success: false };
+        }
+        // Ensure extracted resources object exists
+        if (!extractedResources || typeof extractedResources !== 'object') {
+            return { success: false };
+        }
+        // Add the fetcher to utils folder (for server-side use)
+        // Use a unique key to avoid conflicts with API routes
+        extractedResources["utils/".concat(fileName)] = {
+            fileName: fileName,
+            fileType: FileType.JS,
+            path: ['utils', 'data-sources'],
+            content: fetcherCode,
+        };
+        // Add dependency for the fetcher
+        var fetcherImportName = StringUtils.dashCaseToCamelCase(fileName);
+        dependencies[fetcherImportName] = {
+            type: 'local',
+            path: "../utils/data-sources/".concat(fileName),
+        };
+        // Build params object from resource params
+        // tslint:disable-next-line:no-any
+        var resourceParams = ((_a = node.content.resource) === null || _a === void 0 ? void 0 : _a.params) || {};
+        var paramsProperties_1 = [];
+        // tslint:disable-next-line:no-any
+        Object.entries(resourceParams).forEach(function (_a) {
+            var key = _a[0], value = _a[1];
+            if (value.type === 'static') {
+                var astValue = void 0;
+                if (value.content === null || value.content === undefined) {
+                    astValue = types.nullLiteral();
+                }
+                else if (Array.isArray(value.content)) {
+                    // Handle array values (like queryColumns)
+                    astValue = types.arrayExpression(value.content.map(function (item) {
+                        if (typeof item === 'string') {
+                            return types.stringLiteral(item);
+                        }
+                        if (typeof item === 'number') {
+                            return types.numericLiteral(item);
+                        }
+                        if (typeof item === 'boolean') {
+                            return types.booleanLiteral(item);
+                        }
+                        return types.nullLiteral();
+                    }));
+                }
+                else if (typeof value.content === 'string') {
+                    astValue = types.stringLiteral(value.content);
+                }
+                else if (typeof value.content === 'number') {
+                    astValue = types.numericLiteral(value.content);
+                }
+                else if (typeof value.content === 'boolean') {
+                    astValue = types.booleanLiteral(value.content);
+                }
+                else {
+                    astValue = types.nullLiteral();
+                }
+                paramsProperties_1.push(types.objectProperty(types.stringLiteral(key), astValue));
+            }
+            // Note: We don't handle 'expr' or 'dynamic' params in getStaticProps
+            // as those should be detected by hasResourceDynamicParams check earlier
+        });
+        var fetchCallExpression = types.callExpression(types.memberExpression(types.identifier(fetcherImportName), types.identifier('fetchData')), [types.objectExpression(paramsProperties_1)]);
+        var safeFetchExpression = createSafeFetchExpression(fetchCallExpression, propKey_1);
+        // Get response value path (if specified)
+        var responseMemberAST = node.content.valuePath
+            ? ASTUtils.generateMemberExpressionASTFromPath(__spreadArray([
+                propKey_1
+            ], ASTUtils.parseValuePath(node.content.valuePath), true))
+            : types.identifier(propKey_1);
+        // Create or update getStaticProps chunk
+        var tryBlock = null;
+        if (!getStaticPropsChunk) {
+            tryBlock = types.tryStatement(types.blockStatement([
+                types.returnStatement(types.objectExpression([
+                    types.objectProperty(types.identifier('props'), types.objectExpression([
+                        types.objectProperty(types.identifier(propKey_1), responseMemberAST, false, false),
+                    ])),
+                    types.objectProperty(types.identifier('revalidate'), types.numericLiteral(1)),
+                ])),
+            ]), types.catchClause(types.identifier('error'), types.blockStatement([
+                types.expressionStatement(types.callExpression(types.memberExpression(types.identifier('console'), types.identifier('error')), [types.stringLiteral('Error in getStaticProps:'), types.identifier('error')])),
+                types.returnStatement(types.objectExpression([
+                    types.objectProperty(types.identifier('props'), types.objectExpression([])),
+                ])),
+            ])));
+            getStaticPropsChunk = {
+                name: 'getStaticProps',
+                type: ChunkType.AST,
+                fileType: FileType.JS,
+                content: types.exportNamedDeclaration(types.functionDeclaration(types.identifier('getStaticProps'), [types.identifier('context')], types.blockStatement([tryBlock]), false, true)),
+                linkAfter: ['jsx-component'],
+            };
+            chunks.push(getStaticPropsChunk);
+        }
+        else {
+            // Update existing getStaticProps
+            var functionDeclaration = getStaticPropsChunk.content
+                .declaration;
+            var functionBody = functionDeclaration.body.body;
+            tryBlock = functionBody.find(function (subNode) { return subNode.type === 'TryStatement'; });
+            if (!tryBlock) {
+                return { success: false };
+            }
+        }
+        if (!tryBlock) {
+            return { success: false };
+        }
+        // Ensure props include current data source
+        var returnStatement = tryBlock.block.body.find(function (subNode) { return subNode.type === 'ReturnStatement'; });
+        if (!returnStatement) {
+            return { success: false };
+        }
+        var propsObject = returnStatement.argument.properties.find(function (property) { return property.key.name === 'props'; });
+        var propsValue = propsObject.value;
+        // Check if propKey already exists in the parallel fetch metadata
+        var parallelFetchMeta = (_b = getStaticPropsChunk.meta) === null || _b === void 0 ? void 0 : _b.parallelFetch;
+        var existingInFetchMeta = parallelFetchMeta === null || parallelFetchMeta === void 0 ? void 0 : parallelFetchMeta.names.includes(propKey_1);
+        // Always ensure both the fetch and the prop are in sync
+        if (!existingInFetchMeta) {
+            // Add to parallel fetch metadata
+            registerParallelFetch(getStaticPropsChunk, tryBlock, propKey_1, safeFetchExpression);
+            // Check if prop exists in return object
+            var existingProp = propsValue.properties.find(function (prop) {
+                return prop.type === 'ObjectProperty' &&
+                    prop.key.type === 'Identifier' &&
+                    prop.key.name === propKey_1;
+            });
+            // Add prop if it doesn't exist
+            if (!existingProp) {
+                propsValue.properties.unshift(types.objectProperty(types.identifier(propKey_1), responseMemberAST, false, false));
+            }
+        }
+        return { success: true, chunk: getStaticPropsChunk };
+    }
+    catch (error) {
+        return { success: false };
+    }
+};
+var createSafeFetchExpression = function (fetchCallExpression, label) {
+    var errorIdentifier = types.identifier('error');
+    var catchHandler = types.arrowFunctionExpression([errorIdentifier], types.blockStatement([
+        types.expressionStatement(types.callExpression(types.memberExpression(types.identifier('console'), types.identifier('error')), [types.stringLiteral("Error fetching ".concat(label, ":")), errorIdentifier])),
+        types.returnStatement(types.arrayExpression([])),
+    ]));
+    return types.callExpression(types.memberExpression(fetchCallExpression, types.identifier('catch')), [catchHandler]);
+};
+var registerParallelFetch = function (getStaticPropsChunk, tryBlock, propKey, expression) {
+    var _a;
+    if (!getStaticPropsChunk.meta) {
+        getStaticPropsChunk.meta = {};
+    }
+    var meta = (_a = getStaticPropsChunk.meta.parallelFetchData) !== null && _a !== void 0 ? _a : (getStaticPropsChunk.meta.parallelFetchData = {
+        names: [],
+        expressions: [],
+    });
+    meta.names.push(propKey);
+    meta.expressions.push(expression);
+    updateParallelFetchStatement(tryBlock, meta);
+};
+var updateParallelFetchStatement = function (tryBlock, meta) {
+    if (meta.declaration) {
+        var existingIndex = tryBlock.block.body.indexOf(meta.declaration);
+        if (existingIndex !== -1) {
+            tryBlock.block.body.splice(existingIndex, 1);
+        }
+    }
+    var promiseAllCall = types.awaitExpression(types.callExpression(types.memberExpression(types.identifier('Promise'), types.identifier('all')), [types.arrayExpression(meta.expressions.map(function (expression) { return expression; }))]));
+    var arrayPattern = types.arrayPattern(meta.names.map(function (name) { return types.identifier(name); }));
+    meta.declaration = types.variableDeclaration('const', [
+        types.variableDeclarator(arrayPattern, promiseAllCall),
+    ]);
+    tryBlock.block.body.unshift(meta.declaration);
+};
+//# sourceMappingURL=utils.js.map