@hubspot/project-parsing-lib 0.2.0 → 0.2.1-experimental.0

package/src/lib/platformVersion.d.ts

@@ -0,0 +1,3 @@
+export declare const LATEST_SUPPORTED_PLATFORM_VERSION: string;
+export declare function isSupportedPlatformVersion(platformVersion?: string | null): boolean;
+export declare function isLegacyProject(platformVersion?: string | null): boolean;

package/src/lib/platformVersion.js

@@ -0,0 +1,16 @@
+import { PLATFORM_VERSIONS } from './constants.js';
+// Used for logging suggestions to users whenever we encouter an unknown version
+export const LATEST_SUPPORTED_PLATFORM_VERSION = PLATFORM_VERSIONS.v2026_03;
+// We are unable to reliably interact versions of projects that are not officially supported by this library
+export function isSupportedPlatformVersion(platformVersion) {
+    if (!platformVersion || typeof platformVersion !== 'string') {
+        return false;
+    }
+    const supportedPlatformVersions = Object.values(PLATFORM_VERSIONS);
+    return supportedPlatformVersions.includes(platformVersion);
+}
+export function isLegacyProject(platformVersion) {
+    if (!platformVersion)
+        return false;
+    return [PLATFORM_VERSIONS.v2023_2, PLATFORM_VERSIONS.v2025_1].includes(platformVersion);
+}

package/src/lib/profiles.d.ts

@@ -1,5 +1,10 @@
-import { FileParseResult, HsProfileFile } from './types';
+import { FileParseResult, HsProfileFile, HSProfileVariables } from './types.js';
 export declare function getIsProfileFile(filename: string): boolean;
 export declare function getHsProfileFilename(profileName: string): string;
 export declare function getHsProfileName(profileFilename: string): string;
+export declare function getHsProfileVariables(hsProfileContents: HsProfileFile): HSProfileVariables;
+export declare function validateProfileVariables(profileVariables: HSProfileVariables, filename: string): {
+    success: boolean;
+    errors: string[];
+};
 export declare function applyHsProfileVariables(fileParseResults: FileParseResult[], hsProfileContents: HsProfileFile): FileParseResult[];

package/src/lib/profiles.js

@@ -1,56 +1,111 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getIsProfileFile = getIsProfileFile;
-exports.getHsProfileFilename = getHsProfileFilename;
-exports.getHsProfileName = getHsProfileName;
-exports.applyHsProfileVariables = applyHsProfileVariables;
-const constants_1 = require("./constants");
-const copy_1 = require("../lang/copy");
-const profileFilenameRegex = new RegExp(`^${constants_1.profileFilePrefix}\\.([^.]+)\\.json$`);
+import { PROFILE_FILE_PREFIX } from './constants.js';
+import { errorMessages } from '../lang/copy.js';
+const profileFilenameRegex = new RegExp(`^${PROFILE_FILE_PREFIX}\\.([^.]+)\\.json$`);
+// Regex to match variable placeholders like ${variableName}
 const profileInsertRegex = /\${(.*?)}/g;
-function getIsProfileFile(filename) {
+// Helper to check if string is a single variable reference (e.g., "${port}" but not "http://${port}")
+// Returns the variable key if it matches, null otherwise
+function isSingleVariableReference(str) {
+    const match = str.match(/^\${([^}]+)}$/);
+    return match ? match[1] : null;
+}
+export function getIsProfileFile(filename) {
     return profileFilenameRegex.test(filename);
 }
-function getHsProfileFilename(profileName) {
-    return `${constants_1.profileFilePrefix}.${profileName}.json`;
+export function getHsProfileFilename(profileName) {
+    return `${PROFILE_FILE_PREFIX}.${profileName}.json`;
 }
-function getHsProfileName(profileFilename) {
+export function getHsProfileName(profileFilename) {
     const match = profileFilename.match(profileFilenameRegex);
     return match ? match[1] : '';
 }
-function interpolate(file, template, profileVariables) {
-    return template.replace(profileInsertRegex, (__match, key) => {
-        const profileVariableType = typeof profileVariables[key];
-        if (profileVariableType === 'undefined') {
-            throw new Error(copy_1.errorMessages.profile.missingValue(key, file));
+export function getHsProfileVariables(hsProfileContents) {
+    const profileVariablesAreValid = hsProfileContents?.variables &&
+        typeof hsProfileContents.variables === 'object' &&
+        !Array.isArray(hsProfileContents.variables);
+    return profileVariablesAreValid ? hsProfileContents.variables : {};
+}
+export function validateProfileVariables(profileVariables, filename) {
+    const errors = [];
+    for (const [variableKey, variableValue] of Object.entries(profileVariables)) {
+        try {
+            const variableType = typeof variableValue;
+            validateProfileVariable(variableType, variableKey, filename);
         }
-        if (!['string', 'number', 'boolean'].includes(profileVariableType)) {
-            throw new Error(copy_1.errorMessages.profile.invalidValue(key));
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            errors.push(errorMessage);
         }
-        return String(profileVariables[key]);
+    }
+    return {
+        success: errors.length === 0,
+        errors,
+    };
+}
+function validateProfileVariable(variableType, variableKey, filename) {
+    const allowedTypes = ['string', 'number', 'boolean'];
+    if (variableType === 'undefined') {
+        throw new Error(errorMessages.profile.missingValue(variableKey, filename));
+    }
+    if (!allowedTypes.includes(variableType)) {
+        throw new Error(errorMessages.profile.invalidValue(variableKey));
+    }
+}
+function interpolate(file, template, profileVariables) {
+    return template.replace(profileInsertRegex, (_fullMatch, variableKey) => {
+        const variableValue = profileVariables[variableKey];
+        const variableType = typeof variableValue;
+        validateProfileVariable(variableType, variableKey, file);
+        return String(variableValue);
     });
 }
-function applyHsProfileVariables(fileParseResults, hsProfileContents) {
-    const profileVariables = hsProfileContents?.variables &&
-        typeof hsProfileContents.variables === 'object' &&
-        !Array.isArray(hsProfileContents.variables)
-        ? hsProfileContents.variables
-        : {};
+function replaceVariablesInValue(value, file, profileVariables) {
+    // Handle string values with variable substitution
+    if (typeof value === 'string') {
+        // If the entire value is a single variable (e.g., "${port}"),
+        // return the typed value to preserve number/boolean types
+        const variableKey = isSingleVariableReference(value);
+        if (variableKey) {
+            const variableValue = profileVariables[variableKey];
+            const variableType = typeof variableValue;
+            validateProfileVariable(variableType, variableKey, file);
+            return variableValue;
+        }
+        // Otherwise, perform string interpolation (no-op if no variables found)
+        // For strings with multiple variables (e.g., "http://${host}:${port}"),
+        // this converts all values to strings
+        return interpolate(file, value, profileVariables);
+    }
+    // Recursively handle arrays
+    if (Array.isArray(value)) {
+        return value.map(item => replaceVariablesInValue(item, file, profileVariables));
+    }
+    // Recursively handle objects
+    if (value !== null && typeof value === 'object') {
+        const result = {};
+        for (const [key, val] of Object.entries(value)) {
+            result[key] = replaceVariablesInValue(val, file, profileVariables);
+        }
+        return result;
+    }
+    // Return primitive values as-is
+    return value;
+}
+export function applyHsProfileVariables(fileParseResults, hsProfileContents) {
+    const profileVariables = getHsProfileVariables(hsProfileContents);
     return fileParseResults.map(fileParseResult => {
         const { content, file } = fileParseResult;
-        if (content && content.config) {
-            let interpolatedConfig = content.config;
-            interpolatedConfig = JSON.parse(interpolate(file, JSON.stringify(content.config), profileVariables));
-            if (interpolatedConfig) {
-                return {
-                    ...fileParseResult,
-                    content: {
-                        ...content,
-                        config: interpolatedConfig,
-                    },
-                };
-            }
+        // Only process files that have content with a config section
+        if (!content?.config) {
+            return fileParseResult;
         }
-        return fileParseResult;
+        const configWithVariablesReplaced = replaceVariablesInValue(content.config, file, profileVariables);
+        return {
+            ...fileParseResult,
+            content: {
+                ...content,
+                config: configWithVariablesReplaced,
+            },
+        };
     });
 }

package/src/lib/project.d.ts

@@ -0,0 +1,13 @@
+export interface ComponentMetadata {
+    count: number;
+    maxCount: number;
+    hsMetaFiles: string[];
+}
+export interface ComponentMetadataMap {
+    [componentType: string]: ComponentMetadata;
+}
+export interface ProjectMetadata {
+    hsMetaFiles: string[];
+    components: ComponentMetadataMap;
+}
+export declare function getProjectMetadata(projectSrcDir: string): Promise<ProjectMetadata>;

package/src/lib/project.js

@@ -0,0 +1,36 @@
+import { Components } from './constants.js';
+import { locateHsMetaFiles } from './files.js';
+import path from 'path';
+import fs from 'fs';
+export async function getProjectMetadata(projectSrcDir) {
+    const hsMetaFiles = [];
+    const components = {};
+    let metafiles = [];
+    if (fs.existsSync(projectSrcDir)) {
+        metafiles = await locateHsMetaFiles(projectSrcDir, { silent: true });
+    }
+    const seenComponentPaths = new Map();
+    Object.keys(Components).forEach(componentType => {
+        const { parentComponent, singularComponent, dir } = Components[componentType];
+        const componentPath = path.join(projectSrcDir, parentComponent ? path.join(parentComponent, dir) : dir);
+        if (seenComponentPaths.has(componentPath)) {
+            components[componentType] = seenComponentPaths.get(componentPath);
+            return;
+        }
+        const metaFilesByType = metafiles
+            .filter(metafile => path.parse(metafile.file).dir === componentPath)
+            .map(metaFile => metaFile.file);
+        const metadata = {
+            hsMetaFiles: metaFilesByType,
+            count: metaFilesByType.length,
+            maxCount: singularComponent ? 1 : Infinity,
+        };
+        hsMetaFiles.push(...metaFilesByType);
+        seenComponentPaths.set(componentPath, metadata);
+        components[componentType] = metadata;
+    });
+    return {
+        hsMetaFiles,
+        components,
+    };
+}

package/src/lib/schemas.d.ts

@@ -1,3 +1,3 @@
-import { AnySchema } from 'ajv/dist/2020';
-import { TranslationContext } from './types';
+import type { AnySchema } from 'ajv';
+import { TranslationContext } from './types.js';
 export declare function getIntermediateRepresentationSchema(translationContext: TranslationContext): Promise<Record<string, AnySchema>>;

package/src/lib/schemas.js

@@ -1,24 +1,24 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getIntermediateRepresentationSchema = getIntermediateRepresentationSchema;
-const http_1 = require("@hubspot/local-dev-lib/http");
-const index_1 = require("@hubspot/local-dev-lib/errors/index");
-const copy_1 = require("../lang/copy");
-async function getIntermediateRepresentationSchema(translationContext) {
+import { http } from '@hubspot/local-dev-lib/http';
+import { isHubSpotHttpError, isSpecifiedError, } from '@hubspot/local-dev-lib/errors/index';
+import { errorMessages } from '../lang/copy.js';
+export async function getIntermediateRepresentationSchema(translationContext) {
     if (!translationContext.accountId) {
-        throw new Error(copy_1.errorMessages.api.accountIdIsRequiredToFetchSchemas);
+        throw new Error(errorMessages.api.accountIdIsRequiredToFetchSchemas);
     }
     try {
         const { accountId, platformVersion } = translationContext;
-        const { data } = await http_1.http.get(accountId, {
+        const { data } = await http.get(accountId, {
             url: `project-components-external/project-schemas/v3/${platformVersion}`,
         });
         return data;
     }
     catch (e) {
-        if ((0, index_1.isHubSpotHttpError)(e)) {
+        if (isSpecifiedError(e, { statusCode: 403 })) {
+            throw new Error(errorMessages.api.failedToFetchSchemas403, { cause: e });
+        }
+        if (isHubSpotHttpError(e)) {
             throw e;
         }
-        throw new Error(copy_1.errorMessages.api.failedToFetchSchemas, { cause: e });
+        throw new Error(errorMessages.api.failedToFetchSchemas, { cause: e });
     }
 }

package/src/lib/transform.d.ts

@@ -1,9 +1,11 @@
-import { Dependencies, FileParseResult, HsProfileFile, IntermediateRepresentation, Transformation, TranslationContext } from './types';
+import { Dependencies, FileParseResult, HsProfileFile, IntermediateRepresentation, Transformation, TranslationContext } from './types.js';
 export declare function mapToInternalType(type: string): string;
 export declare function mapToUserFacingType(type: string): string;
 export declare function mapToUserFriendlyName(internalType: string): string;
+export declare function findTransformationByUid(transformations: Transformation[], uid: string): Transformation | undefined;
 export declare function transform(fileParseResults: FileParseResult[], translationContext: TranslationContext, hsProfileContents?: HsProfileFile): Transformation[];
-export declare function getIntermediateRepresentation(transformations: Transformation[], skipValidation: boolean | undefined): IntermediateRepresentation;
+export declare function getIntermediateRepresentation(transformations: Transformation[], hsProfileContents?: HsProfileFile, skipValidation?: boolean): IntermediateRepresentation;
+export declare function getParsingErrors(transformations: Transformation[]): FileParseResult[];
 export declare function generateServerlessPackageComponent(appFunctionsDirectory: string, translationContext: TranslationContext, componentDeps: Dependencies): {
     uid: string;
     transformation: Transformation;

package/src/lib/transform.js

@@ -1,19 +1,11 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mapToInternalType = mapToInternalType;
-exports.mapToUserFacingType = mapToUserFacingType;
-exports.mapToUserFriendlyName = mapToUserFriendlyName;
-exports.transform = transform;
-exports.getIntermediateRepresentation = getIntermediateRepresentation;
-exports.generateServerlessPackageComponent = generateServerlessPackageComponent;
-const profiles_1 = require("./profiles");
-const constants_1 = require("./constants");
-const copy_1 = require("../lang/copy");
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
+import path from 'path';
+import fs from 'fs';
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { applyHsProfileVariables, getHsProfileVariables } from './profiles.js';
+import { APP_KEY, APP_OBJECT_KEY, Components, PROJECT_STRUCTURE, APP_FUNCTIONS_KEY, APP_FUNCTIONS_PACKAGE_KEY, USER_FACING_TO_INTERNAL_TYPE, INTERNAL_TYPE_TO_USER_FACING, PACKAGE_JSON, PACKAGE_LOCK_JSON, PROFILE_VARIABLE_TYPES, } from './constants.js';
+import { errorMessages } from '../lang/copy.js';
+import { getJavaNumberType } from './utils.js';
+import { convertPathToPosixPath } from './files.js';
 function calculateComponentDeps(fileValidationResult, parentComponents, appObjects, appFunctionsPackageUid) {
     let dependencies = {};
     // If there are dependencies in the config file, pass them through
@@ -22,55 +14,65 @@ function calculateComponentDeps(fileValidationResult, parentComponents, appObjec
     }
     const { type } = fileValidationResult.content;
     // If the component is a child of the App component, add the app and appObjects as dependencies
-    if (constants_1.Components[type]?.parentComponent === constants_1.AppKey) {
-        const parentUid = parentComponents[fileValidationResult.parentDirectory];
+    if (Components[type]?.parentComponent === APP_KEY) {
+        const parentUid = parentComponents[APP_KEY];
         if (parentUid) {
             dependencies.app = parentUid;
         }
-        if (type !== constants_1.AppObjectKey) {
+        else {
+            logger.debug(parentComponents);
+            return {
+                dependencies,
+                errors: [errorMessages.project.mustHaveAppComponent(type)],
+            };
+        }
+        if (type !== APP_OBJECT_KEY) {
             dependencies.allAppObjects = appObjects;
         }
-        if (type === constants_1.AppFunctionsKey && appFunctionsPackageUid) {
+        if (type === APP_FUNCTIONS_KEY && appFunctionsPackageUid) {
             dependencies.serverlessPackage = appFunctionsPackageUid;
         }
     }
-    return dependencies;
+    return { dependencies };
 }
-function mapToInternalType(type) {
-    const resolvedType = constants_1.userFacingToInternalType[type] || type || '';
+export function mapToInternalType(type) {
+    const resolvedType = USER_FACING_TO_INTERNAL_TYPE[type] || type || '';
     return resolvedType.toUpperCase().replace(/-/g, '_');
 }
-function mapToUserFacingType(type) {
-    return (constants_1.internalTypeToUserFacing[type] || type || '')
+export function mapToUserFacingType(type) {
+    return (INTERNAL_TYPE_TO_USER_FACING[type] || type || '')
         .toLowerCase()
         .replace(/_/g, '-');
 }
-function mapToUserFriendlyName(internalType) {
-    return constants_1.Components[mapToUserFacingType(internalType)]?.userFriendlyName || '';
+export function mapToUserFriendlyName(internalType) {
+    return Components[mapToUserFacingType(internalType)]?.userFriendlyName || '';
 }
-function transform(fileParseResults, translationContext, hsProfileContents) {
-    const parentTypes = Object.keys(constants_1.ProjectStructure);
+export function findTransformationByUid(transformations, uid) {
+    return transformations.find(t => t.intermediateRepresentation?.uid === uid);
+}
+export function transform(fileParseResults, translationContext, hsProfileContents) {
+    const parentTypes = Object.keys(PROJECT_STRUCTURE);
     const parentComponents = {};
     const allAppObjects = [];
     let appUid = '';
     let appFunctionsDirectory;
     // Apply the profile variable overrides to the config
     if (hsProfileContents) {
-        fileParseResults = (0, profiles_1.applyHsProfileVariables)(fileParseResults, hsProfileContents);
+        fileParseResults = applyHsProfileVariables(fileParseResults, hsProfileContents);
     }
     // Compute the parent components, so we can add them as dependencies to the child components
     fileParseResults.forEach(file => {
         if (file.content?.type && parentTypes.includes(file.content.type)) {
-            if (file.content.type === constants_1.AppKey) {
+            if (file.content.type === APP_KEY) {
                 appUid = file.content.uid;
             }
             parentComponents[file.content.type] = file.content.uid;
         }
-        if (file.content?.type === constants_1.AppObjectKey) {
+        if (file.content?.type === APP_OBJECT_KEY) {
             allAppObjects.push(file.content.uid);
         }
-        if (file.content?.type === constants_1.AppFunctionsKey) {
-            appFunctionsDirectory = path_1.default.dirname(file.file);
+        if (file.content?.type === APP_FUNCTIONS_KEY) {
+            appFunctionsDirectory = path.dirname(file.file);
         }
     });
     const autoGeneratedComponents = [];
@@ -85,20 +87,26 @@ function transform(fileParseResults, translationContext, hsProfileContents) {
     }
     const transformations = fileParseResults.map((currentFile) => {
         if (!currentFile.content) {
-            currentFile.errors?.push(copy_1.errorMessages.project.fileContentMissingFor(currentFile.file));
+            if (!currentFile.errors?.includes(errorMessages.validation.invalidJson)) {
+                currentFile.errors?.push(errorMessages.project.fileContentMissingFor(currentFile.file));
+            }
             return {
                 intermediateRepresentation: null,
                 fileParseResult: currentFile,
             };
         }
         const { config, uid, type } = currentFile.content;
+        const { dependencies, errors } = calculateComponentDeps(currentFile, parentComponents, allAppObjects, serverlessPackageUid);
+        if (errors) {
+            currentFile.errors?.push(...errors);
+        }
         return {
             intermediateRepresentation: {
                 uid,
                 config,
                 componentType: mapToInternalType(type),
-                componentDeps: calculateComponentDeps(currentFile, parentComponents, allAppObjects, serverlessPackageUid),
-                metaFilePath: currentFile.file,
+                componentDeps: dependencies,
+                metaFilePath: convertPathToPosixPath(currentFile.file),
                 files: {},
             },
             fileParseResult: currentFile,
@@ -106,7 +114,7 @@ function transform(fileParseResults, translationContext, hsProfileContents) {
     });
     return [...autoGeneratedComponents, ...transformations];
 }
-function getIntermediateRepresentation(transformations, skipValidation) {
+export function getIntermediateRepresentation(transformations, hsProfileContents, skipValidation) {
     const nodes = transformations.reduce((acc, current) => {
         if (!current.intermediateRepresentation) {
             return acc;
@@ -116,15 +124,14 @@ function getIntermediateRepresentation(transformations, skipValidation) {
             const duplicates = transformations
                 .filter(t => t.intermediateRepresentation?.uid === uid)
                 .map(t => t.fileParseResult.file);
-            throw new Error(copy_1.errorMessages.project.duplicateUid(uid, duplicates));
+            throw new Error(errorMessages.project.duplicateUid(uid, duplicates));
         }
         if (!skipValidation) {
             return {
                 ...acc,
                 // If the uid is not defined just make one up for the sake of indexing.
                 // It will still fail validation, but this prevents collisions so we validate all files.
-                [uid ||
-                    `missing-${current.fileParseResult.file}`]: current.intermediateRepresentation,
+                [uid || `missing-${current.fileParseResult.file}`]: current.intermediateRepresentation,
             };
         }
         return {
@@ -132,17 +139,55 @@ function getIntermediateRepresentation(transformations, skipValidation) {
             [uid]: current.intermediateRepresentation,
         };
     }, {});
+    const profileData = getProfileData(hsProfileContents);
     return {
         intermediateNodesIndexedByUid: nodes,
+        profileData,
     };
 }
-function generateServerlessPackageComponent(appFunctionsDirectory, translationContext, componentDeps) {
-    const packageFile = path_1.default.join(appFunctionsDirectory, constants_1.packageJson);
-    const packageLockFile = path_1.default.join(appFunctionsDirectory, constants_1.packageLockJson);
-    const { projectSourceDir } = translationContext;
-    const appFunctionsPackageFile = path_1.default.join(projectSourceDir, packageFile);
-    if (!fs_1.default.existsSync(appFunctionsPackageFile)) {
-        throw new Error(copy_1.errorMessages.project.noPackageJsonForServerless(appFunctionsPackageFile));
+export function getParsingErrors(transformations) {
+    return transformations
+        .filter(t => t.fileParseResult.errors.length > 0)
+        .map(t => t.fileParseResult);
+}
+function getProfileData(hsProfileContents) {
+    const profileVariablesForBE = {};
+    if (hsProfileContents && hsProfileContents.variables) {
+        const profileVariables = getHsProfileVariables(hsProfileContents);
+        Object.keys(profileVariables).forEach(key => {
+            const profileVar = profileVariables[key];
+            let variableTypeForBE;
+            switch (typeof profileVar) {
+                case 'string':
+                    variableTypeForBE = PROFILE_VARIABLE_TYPES.PROFILE_STRING;
+                    break;
+                case 'number':
+                    variableTypeForBE = getJavaNumberType(profileVar);
+                    break;
+                case 'boolean':
+                    variableTypeForBE = PROFILE_VARIABLE_TYPES.PROFILE_BOOLEAN;
+                    break;
+                default:
+                    break;
+            }
+            if (variableTypeForBE) {
+                profileVariablesForBE[key] = {
+                    variableType: variableTypeForBE,
+                    value: profileVar,
+                };
+            }
+        });
+    }
+    return { vars: { profileVariables: profileVariablesForBE } };
+}
+export function generateServerlessPackageComponent(appFunctionsDirectory, translationContext, componentDeps) {
+    const appFunctionsPosix = convertPathToPosixPath(appFunctionsDirectory);
+    const packageFilePosix = path.posix.join(appFunctionsPosix, PACKAGE_JSON);
+    const packageLockFilePosix = path.posix.join(appFunctionsPosix, PACKAGE_LOCK_JSON);
+    const projectSourceDirPosix = convertPathToPosixPath(translationContext.projectSourceDir);
+    const appFunctionsPackageFile = path.posix.join(projectSourceDirPosix, packageFilePosix);
+    if (!fs.existsSync(appFunctionsPackageFile)) {
+        throw new Error(errorMessages.project.noPackageJsonForServerless(appFunctionsPackageFile));
     }
     const uid = `hubspot-serverless-package-uid`;
     return {
@@ -154,15 +199,17 @@ function generateServerlessPackageComponent(appFunctionsDirectory, translationCo
             },
             intermediateRepresentation: {
                 uid,
-                componentType: mapToInternalType(constants_1.AppFunctionsPackageKey),
+                componentType: mapToInternalType(APP_FUNCTIONS_PACKAGE_KEY),
                 config: {
-                    packageFile,
-                    packageLockfile: fs_1.default.existsSync(path_1.default.join(projectSourceDir, packageLockFile))
-                        ? packageLockFile
+                    packageFile: packageFilePosix,
+                    packageLockfile: fs.existsSync(
+                    // Don't use posix here because we are checking the file system
+                    path.join(translationContext.projectSourceDir, path.join(appFunctionsDirectory, PACKAGE_LOCK_JSON)))
+                        ? packageLockFilePosix
                         : undefined,
                 },
                 componentDeps,
-                metaFilePath: packageFile,
+                metaFilePath: packageFilePosix,
                 files: {},
             },
         },

package/src/lib/translate.d.ts

@@ -0,0 +1,3 @@
+import { IntermediateRepresentation, IntermediateRepresentationLocalDev, TranslationContext, TranslationOptions, TranslationOptionsLocalDev } from './types.js';
+export declare function translate(translationContext: TranslationContext, translationOptions?: TranslationOptions): Promise<IntermediateRepresentation>;
+export declare function translateForLocalDev(translationContext: TranslationContext, translationOptions?: TranslationOptionsLocalDev): Promise<IntermediateRepresentationLocalDev>;

package/src/lib/translate.js

@@ -0,0 +1,62 @@
+import { loadHsProfileFile, loadHsMetaFiles } from './files.js';
+import { validateIntermediateRepresentation } from './validation.js';
+import { getIntermediateRepresentation, getParsingErrors, transform, } from './transform.js';
+import { errorMessages } from '../lang/copy.js';
+import { getLocalDevProfileData, getLocalDevProjectNodes, getRemovedNodesAndNodesWithErrors, } from './localDev.js';
+import { isSupportedPlatformVersion } from './platformVersion.js';
+const defaultOptions = {
+    skipValidation: false,
+};
+export async function translate(translationContext, translationOptions = defaultOptions) {
+    const { skipValidation, profile } = translationOptions;
+    if (!skipValidation &&
+        !isSupportedPlatformVersion(translationContext.platformVersion)) {
+        throw new Error(errorMessages.project.unsupportedPlatformVersion(translationContext.platformVersion));
+    }
+    const metafileContents = await loadHsMetaFiles(translationContext);
+    if (metafileContents.length === 0) {
+        throw new Error(errorMessages.project.noHsMetaFiles);
+    }
+    let hsProfileContents;
+    if (profile) {
+        hsProfileContents = loadHsProfileFile(translationContext.projectSourceDir, profile);
+    }
+    const transformations = transform(metafileContents, translationContext, hsProfileContents);
+    const intermediateRepresentation = getIntermediateRepresentation(transformations, hsProfileContents, skipValidation);
+    // Remove once extensions and serverless functions are supported
+    if (!skipValidation) {
+        await validateIntermediateRepresentation(intermediateRepresentation, transformations, translationContext);
+    }
+    return intermediateRepresentation;
+}
+export async function translateForLocalDev(translationContext, translationOptions) {
+    const { skipValidation, profile, projectNodesAtLastUpload } = translationOptions || {};
+    if (!skipValidation &&
+        !isSupportedPlatformVersion(translationContext.platformVersion)) {
+        throw new Error(errorMessages.project.unsupportedPlatformVersion(translationContext.platformVersion));
+    }
+    const metafileContents = await loadHsMetaFiles(translationContext);
+    if (metafileContents.length === 0) {
+        throw new Error(errorMessages.project.noHsMetaFiles);
+    }
+    let hsProfileContents;
+    if (profile) {
+        hsProfileContents = loadHsProfileFile(translationContext.projectSourceDir, profile);
+    }
+    const transformation = transform(metafileContents, translationContext, hsProfileContents);
+    const baseIntermediateRepresentation = getIntermediateRepresentation(transformation, hsProfileContents, true);
+    const parsingErrors = getParsingErrors(transformation);
+    const projectNodes = getLocalDevProjectNodes(baseIntermediateRepresentation.intermediateNodesIndexedByUid, translationContext.projectSourceDir, projectNodesAtLastUpload);
+    let projectNodesWithErrors = {};
+    if (projectNodesAtLastUpload) {
+        projectNodesWithErrors = getRemovedNodesAndNodesWithErrors(baseIntermediateRepresentation.intermediateNodesIndexedByUid, projectNodesAtLastUpload, parsingErrors);
+    }
+    const profileData = getLocalDevProfileData(baseIntermediateRepresentation.profileData?.vars.profileVariables);
+    return {
+        intermediateNodesIndexedByUid: {
+            ...projectNodes,
+            ...projectNodesWithErrors,
+        },
+        profileData,
+    };
+}