@ldsg/utils 0.3.25 → 0.3.27

package/dist/index.cjs

@@ -0,0 +1,440 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    ZipAppDataLayout: ()=>constants_ZipAppDataLayout,
+    loadAppResourceRecords: ()=>loadAppResourceRecords,
+    generate: ()=>generate,
+    generateByAppData: ()=>generateByAppData,
+    instantiateServices: ()=>instantiateServices,
+    addFileToZipFolder: ()=>addFileToZipFolder,
+    getTreeResourceRecords: ()=>getTreeResourceRecords,
+    zipAppData: ()=>zipAppData,
+    fetchAppData: ()=>fetchAppData,
+    instantiateService: ()=>instantiate_service_instantiateService,
+    getAppData: ()=>getAppData,
+    getHandlerPackageJson: ()=>getHandlerPackageJson,
+    extendAppData: ()=>extendAppData,
+    extendAppDataWithPath: ()=>extendAppDataWithPath,
+    DEFAULT_HANDLER_MODULE_PARENT_DIR_NAME: ()=>DEFAULT_HANDLER_MODULE_PARENT_DIR_NAME,
+    prepare: ()=>prepare,
+    replaceResourceIds: ()=>replaceResourceIds,
+    DEFAULT_APP_MODULE_HANDLER_DEPENDENCY_VERSION_TEMPLATE: ()=>DEFAULT_APP_MODULE_HANDLER_DEPENDENCY_VERSION_TEMPLATE,
+    DEFAULT_APP_MODULE_DIR_NAME: ()=>"app"
+});
+const core_namespaceObject = require("@ldsg/core");
+const instantiateServices = (params)=>{
+    const { serviceRecords, instantiateService = instantiate_service_instantiateService, serviceTypeMap } = params;
+    const services = serviceRecords.map((value)=>{
+        const instantiateServiceRes = instantiateService({
+            serviceProperties: value,
+            serviceTypeMap
+        });
+        const { service } = instantiateServiceRes;
+        return service;
+    });
+    const res = {
+        services: services.map((value)=>{
+            const res = value;
+            res.services = services;
+            return res;
+        })
+    };
+    return res;
+};
+const instantiate_service_instantiateService = (params)=>{
+    const { serviceProperties, serviceRecords, serviceTypeMap } = params;
+    const { type } = serviceProperties;
+    if (!type) throw new Error('service type is required');
+    const ServiceConstructor = serviceTypeMap?.[type]?.class || core_namespaceObject.Service;
+    const service = new ServiceConstructor(serviceProperties);
+    if (serviceRecords) {
+        const { services } = instantiateServices({
+            serviceRecords,
+            serviceTypeMap
+        });
+        service.services = services;
+    }
+    const res = {
+        service
+    };
+    return res;
+};
+const apaas_constants_namespaceObject = require("@ldsg/apaas-constants");
+const constants_namespaceObject = require("@ldsg/constants");
+const external_jszip_namespaceObject = require("jszip");
+var external_jszip_default = /*#__PURE__*/ __webpack_require__.n(external_jszip_namespaceObject);
+const external_lodash_namespaceObject = require("lodash");
+var external_lodash_default = /*#__PURE__*/ __webpack_require__.n(external_lodash_namespaceObject);
+const DEFAULT_APP_MODULE_HANDLER_DEPENDENCY_VERSION_TEMPLATE = 'workspace:*';
+const DEFAULT_HANDLER_MODULE_PARENT_DIR_NAME = 'handlers';
+var constants_ZipAppDataLayout = /*#__PURE__*/ function(ZipAppDataLayout) {
+    ZipAppDataLayout["FLAT"] = "flat";
+    ZipAppDataLayout["NESTED"] = "nested";
+    return ZipAppDataLayout;
+}({});
+const addFileToZipFolder = (params)=>{
+    const { folder, path, data } = params;
+    folder.file(path, external_lodash_default().isObject(data) ? JSON.stringify(data, null, 2) : data);
+};
+const getHandlerPackageJson = (params)=>{
+    const { moduleName, dependencies, reuseMainAppDependencies, packageJson } = params;
+    external_lodash_default().set(packageJson, 'name', moduleName);
+    const packageJsonDependencies = external_lodash_default().omit(external_lodash_default().fromPairs(dependencies.map((value)=>[
+            value.name,
+            value.version ?? 'latest'
+        ])), reuseMainAppDependencies);
+    external_lodash_default().set(packageJson, 'dependencies', packageJsonDependencies);
+    const res = {
+        packageJson
+    };
+    return res;
+};
+const zipAppData = async (params)=>{
+    const { environmentVariables, filesInAppModele = constants_namespaceObject.FILES_IN_APP_TEMPLATE_MODULE, filesInHandlerModele = constants_namespaceObject.FILES_IN_HANDLER_TEMPLATE_MODULE, resourceRecords, reuseMainAppDependencies = [], type, appModuleHandlerDependencyVersionTemplate = DEFAULT_APP_MODULE_HANDLER_DEPENDENCY_VERSION_TEMPLATE, layout = constants_ZipAppDataLayout.NESTED } = params;
+    const rootZip = new (external_jszip_default())();
+    const handlerResourceRecords = resourceRecords.filter((resourceRecord)=>{
+        const { kind } = resourceRecord;
+        return kind === apaas_constants_namespaceObject.ApaasResourceKind.HANDLER;
+    });
+    let appModuleFolder;
+    let handlerModuleParentFolder;
+    switch(layout){
+        case constants_ZipAppDataLayout.FLAT:
+            appModuleFolder = rootZip.folder("app");
+            handlerModuleParentFolder = rootZip;
+            break;
+        case constants_ZipAppDataLayout.NESTED:
+        default:
+            appModuleFolder = rootZip;
+            handlerModuleParentFolder = appModuleFolder.folder(DEFAULT_HANDLER_MODULE_PARENT_DIR_NAME);
+            break;
+    }
+    if (!appModuleFolder) throw new Error('invalid app folder');
+    if (!handlerModuleParentFolder) throw new Error('invalid handler module parent folder');
+    for (const file of filesInAppModele){
+        const { path } = file;
+        let data;
+        switch(path){
+            case 'package.json':
+                {
+                    const packageJson = file.data;
+                    data = {
+                        ...packageJson,
+                        dependencies: {
+                            ...external_lodash_default().fromPairs(handlerResourceRecords.map((handlerResourceRecord)=>{
+                                const { id: moduleName } = handlerResourceRecord;
+                                return [
+                                    moduleName,
+                                    appModuleHandlerDependencyVersionTemplate.replace('MODULE_NAME', moduleName)
+                                ];
+                            })),
+                            ...packageJson.dependencies
+                        }
+                    };
+                    break;
+                }
+            case 'manifest.json':
+                data = external_lodash_default().pick(params, 'resourceRecords');
+                break;
+            case '.env':
+                if (environmentVariables) data = external_lodash_default().toPairs(environmentVariables).map((value)=>value.join('=')).join('\n');
+                break;
+            default:
+                {
+                    const omitPaths = [
+                        '.gitignore',
+                        'pnpm-lock.yaml'
+                    ];
+                    if (!omitPaths.includes(path)) {
+                        if ('data' in file) data = file.data;
+                    }
+                    break;
+                }
+        }
+        if (data) addFileToZipFolder({
+            folder: appModuleFolder,
+            path,
+            data
+        });
+    }
+    if (handlerResourceRecords.length) external_lodash_default().each(handlerResourceRecords, (handlerManifestResource)=>{
+        const { id, settings } = handlerManifestResource;
+        const { code, dependencies } = settings;
+        const handlerFolder = handlerModuleParentFolder.folder(id);
+        if (handlerFolder) for (const file of filesInHandlerModele){
+            const { path } = file;
+            let data;
+            switch(path){
+                case 'index.ts':
+                    data = code;
+                    break;
+                case 'package.json':
+                    {
+                        const { packageJson } = getHandlerPackageJson({
+                            packageJson: file.data,
+                            moduleName: id,
+                            dependencies,
+                            reuseMainAppDependencies
+                        });
+                        data = packageJson;
+                        break;
+                    }
+                default:
+                    if ('data' in file) data = file.data;
+                    break;
+            }
+            if (data) addFileToZipFolder({
+                folder: handlerFolder,
+                path,
+                data
+            });
+        }
+    });
+    const archive = await rootZip.generateAsync({
+        type
+    });
+    const res = {
+        archive
+    };
+    return res;
+};
+const extendAppData = (params)=>{
+    const { appData, extraAppData } = params;
+    const res = {
+        ...extraAppData,
+        ...appData
+    };
+    return res;
+};
+const external_fs_extra_namespaceObject = require("fs-extra");
+var external_fs_extra_default = /*#__PURE__*/ __webpack_require__.n(external_fs_extra_namespaceObject);
+const extendAppDataWithPath = async (params)=>{
+    const { appData, extraAppDataPath } = params;
+    let extraAppData = {};
+    if (extraAppDataPath) {
+        const existsRes = await external_fs_extra_default().exists(extraAppDataPath);
+        if (existsRes) extraAppData = await external_fs_extra_default().readJson(extraAppDataPath);
+    }
+    const res = extendAppData({
+        appData,
+        extraAppData
+    });
+    return res;
+};
+const external_axios_namespaceObject = require("axios");
+var external_axios_default = /*#__PURE__*/ __webpack_require__.n(external_axios_namespaceObject);
+const external_jsonata_namespaceObject = require("jsonata");
+var external_jsonata_default = /*#__PURE__*/ __webpack_require__.n(external_jsonata_namespaceObject);
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const readSourceData = async (uri)=>{
+    if (external_lodash_default().startsWith(uri, 'http')) {
+        const axiosRes = await external_axios_default()({
+            url: uri
+        });
+        return axiosRes.data;
+    }
+    if (external_path_default().isAbsolute(uri)) return external_fs_extra_default().readJson(uri);
+    return external_fs_extra_default().readJson(external_path_default().resolve(process.cwd(), uri));
+};
+const normalizeSourceData = async (rawData, expression)=>{
+    if (expression) {
+        const exp = external_jsonata_default()(expression);
+        return await exp.evaluate(rawData);
+    }
+    return rawData;
+};
+const loadAppResourceRecords = async (params)=>{
+    const { appDataUri, apaasAppDataUri, apaasAppDataExpression } = params;
+    if (apaasAppDataUri) {
+        const rawData = await readSourceData(apaasAppDataUri);
+        const { resourceRecords } = await normalizeSourceData(rawData, apaasAppDataExpression);
+        const apaasRecords = resourceRecords.map((record)=>({
+                id: record.id,
+                kind: record.kind,
+                parentId: record.parentId ?? null,
+                settings: record.settings ?? {}
+            }));
+        return {
+            resourceRecords: apaasRecords,
+            sourceType: 'apaas'
+        };
+    }
+    if (!appDataUri) throw new Error('Missing appDataUri or apaasAppDataUri');
+    const appData = await readSourceData(appDataUri);
+    return {
+        resourceRecords: appData.resourceRecords,
+        sourceType: 'runtime'
+    };
+};
+const fetchAppData = async (params)=>{
+    const { lgsgAppDataUrl: url } = params;
+    const axiosRes = await external_axios_default()({
+        url
+    });
+    const res = axiosRes.data;
+    return res;
+};
+const external_adm_zip_namespaceObject = require("adm-zip");
+var external_adm_zip_default = /*#__PURE__*/ __webpack_require__.n(external_adm_zip_namespaceObject);
+const generateByAppData = async (params)=>{
+    const { appData, outputPath } = params;
+    const zipAppDataRes = await zipAppData({
+        ...appData,
+        type: 'nodebuffer'
+    });
+    const { archive } = zipAppDataRes;
+    const admZip = new (external_adm_zip_default())(archive);
+    admZip.extractAllTo(outputPath, true);
+};
+const getAppData = async (params)=>{
+    const { extraAppDataPath } = params;
+    const appData = await fetchAppData(params);
+    const res = await extendAppDataWithPath({
+        appData,
+        extraAppDataPath
+    });
+    return res;
+};
+const generate = async (params)=>{
+    const { outputPath } = params;
+    const appData = await getAppData(params);
+    await generateByAppData({
+        appData,
+        outputPath
+    });
+};
+const getTreeResourceRecords = (params)=>{
+    const { resourceRecords, rootId } = params;
+    const childrenMap = new Map();
+    for (const r of resourceRecords){
+        if (!r.parentId) continue;
+        const children = childrenMap.get(r.parentId);
+        if (children) children.push(r.id);
+        else childrenMap.set(r.parentId, [
+            r.id
+        ]);
+    }
+    const ids = new Set();
+    const stack = [
+        rootId
+    ];
+    while(stack.length > 0){
+        const id = stack.pop();
+        if (ids.has(id)) continue;
+        ids.add(id);
+        const children = childrenMap.get(id);
+        if (children) stack.push(...children);
+    }
+    const treeResourceRecords = resourceRecords.filter((r)=>ids.has(r.id));
+    const res = {
+        treeResourceRecords
+    };
+    return res;
+};
+const prepare = async (params)=>{
+    const { outputPath } = params;
+    const { archive } = await zipAppData({
+        ...external_lodash_default().omit(params, 'outputPath'),
+        type: 'nodebuffer'
+    });
+    const admZip = new (external_adm_zip_default())(archive);
+    admZip.extractAllTo(outputPath, true);
+};
+const replaceResourceIdsInString = (params)=>{
+    const { jsonString, oldResourceIdToNewResourceIdMap } = params;
+    let result = jsonString;
+    for (const [oldResourceId, newResourceId] of Object.entries(oldResourceIdToNewResourceIdMap))result = result.split(oldResourceId).join(newResourceId);
+    const res = {
+        jsonString: result
+    };
+    return res;
+};
+const replaceResourceIds = (params)=>{
+    const { source, oldResourceIdToNewResourceIdMap } = params;
+    const jsonString = JSON.stringify(source);
+    const { jsonString: replacedJsonString } = replaceResourceIdsInString({
+        jsonString,
+        oldResourceIdToNewResourceIdMap
+    });
+    const replacement = JSON.parse(replacedJsonString);
+    const res = {
+        replacement
+    };
+    return res;
+};
+exports.DEFAULT_APP_MODULE_DIR_NAME = __webpack_exports__.DEFAULT_APP_MODULE_DIR_NAME;
+exports.DEFAULT_APP_MODULE_HANDLER_DEPENDENCY_VERSION_TEMPLATE = __webpack_exports__.DEFAULT_APP_MODULE_HANDLER_DEPENDENCY_VERSION_TEMPLATE;
+exports.DEFAULT_HANDLER_MODULE_PARENT_DIR_NAME = __webpack_exports__.DEFAULT_HANDLER_MODULE_PARENT_DIR_NAME;
+exports.ZipAppDataLayout = __webpack_exports__.ZipAppDataLayout;
+exports.addFileToZipFolder = __webpack_exports__.addFileToZipFolder;
+exports.extendAppData = __webpack_exports__.extendAppData;
+exports.extendAppDataWithPath = __webpack_exports__.extendAppDataWithPath;
+exports.fetchAppData = __webpack_exports__.fetchAppData;
+exports.generate = __webpack_exports__.generate;
+exports.generateByAppData = __webpack_exports__.generateByAppData;
+exports.getAppData = __webpack_exports__.getAppData;
+exports.getHandlerPackageJson = __webpack_exports__.getHandlerPackageJson;
+exports.getTreeResourceRecords = __webpack_exports__.getTreeResourceRecords;
+exports.instantiateService = __webpack_exports__.instantiateService;
+exports.instantiateServices = __webpack_exports__.instantiateServices;
+exports.loadAppResourceRecords = __webpack_exports__.loadAppResourceRecords;
+exports.prepare = __webpack_exports__.prepare;
+exports.replaceResourceIds = __webpack_exports__.replaceResourceIds;
+exports.zipAppData = __webpack_exports__.zipAppData;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEFAULT_APP_MODULE_DIR_NAME",
+    "DEFAULT_APP_MODULE_HANDLER_DEPENDENCY_VERSION_TEMPLATE",
+    "DEFAULT_HANDLER_MODULE_PARENT_DIR_NAME",
+    "ZipAppDataLayout",
+    "addFileToZipFolder",
+    "extendAppData",
+    "extendAppDataWithPath",
+    "fetchAppData",
+    "generate",
+    "generateByAppData",
+    "getAppData",
+    "getHandlerPackageJson",
+    "getTreeResourceRecords",
+    "instantiateService",
+    "instantiateServices",
+    "loadAppResourceRecords",
+    "prepare",
+    "replaceResourceIds",
+    "zipAppData"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/index.d.ts

@@ -1,7 +1,10 @@
+export * from './common';
 export * from './extend-app-data';
 export * from './extend-app-data-with-path';
 export * from './fetch-app-data';
 export * from './generate';
 export * from './generate-by-app-data';
 export * from './get-app-data';
-//# sourceMappingURL=index.d.ts.map
+export * from './get-tree-resource-records';
+export * from './prepare';
+export * from './replace-resource-ids';