Function loadExistingOutputPackFiles

src/nodeExecutor.ts:183–225

(
  packPath: string,
  executionContext?: FlowExecutionContext,
)

});

const loadExistingOutputPackFiles = async (
  packPath: string,
  executionContext?: FlowExecutionContext,
): Promise<NewPackedFile[]> => {
  const cachedOutputPack = executionContext?.outputPackByPath.get(packPath);
  if (cachedOutputPack) {
    return cachedOutputPack.map(cloneNewPackedFile);
  }

  if (!fs.existsSync(packPath)) {
    return [];
  }

  const existingPack = await readPackCached(packPath, {}, executionContext);
  const dbTableNames = existingPack.packedFiles
    .filter((packedFile) => packedFile.name.toLowerCase().startsWith("db\\"))
    .map((packedFile) => {
      const parts = packedFile.name.split("\\");
      return parts.length >= 2 ? `${parts[0]}\\${parts[1]}` : packedFile.name;
    });
  const uniqueTableNames = [...new Set(dbTableNames)];

  if (uniqueTableNames.length > 0) {
    getPacksTableData([existingPack], uniqueTableNames);
    cacheTableFilesForPack(existingPack, uniqueTableNames, executionContext);
  }

  const outputFiles = existingPack.packedFiles
    .filter((packedFile) => packedFile.schemaFields && packedFile.tableSchema)
    .map((packedFile) => ({
      name: packedFile.name,
      schemaFields: packedFile.schemaFields,
      file_size: packedFile.file_size,
      version: packedFile.version,
      tableSchema: packedFile.tableSchema,
    }));

  if (executionContext) {
    executionContext.outputPackByPath.set(packPath, outputFiles.map(cloneNewPackedFile));
  }

  return outputFiles;
};

const mergeOutputPackFiles = async (
  packPath: string,