@ohos-ports/sap-cf-tools 3.3.1-beta.0

package/out/src/cli.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cli = void 0;
+const child_process_1 = require("child_process");
+const comment_json_1 = require("comment-json");
+const _ = require("lodash");
+const types_1 = require("./types");
+class Cli {
+    static execute(args, options, token) {
+        token = token || {
+            isCancellationRequested: false,
+            onCancellationRequested: () => {
+                return;
+            },
+        };
+        Cli.updateSpawnOptions(options);
+        return new Promise((resolve) => {
+            let stderr = "";
+            let stdout = "";
+            if (token.isCancellationRequested) {
+                Cli.cliResultOnExit(stdout, resolve, stderr, types_1.CF_CMD_EXIT_CODE.CANCEL_REQ);
+                return;
+            }
+            const childProcess = (0, child_process_1.spawn)(Cli.CF_CMD, args, options);
+            childProcess.stdin.end();
+            childProcess.stdout.on("data", (data) => {
+                stdout = stdout.concat(data);
+            });
+            childProcess.stderr.on("data", (data) => {
+                stderr = stderr.concat(data);
+            });
+            childProcess.on("exit", (code) => {
+                Cli.cliResultOnExit(stdout, resolve, stderr, code);
+            });
+            childProcess.on("error", (err) => {
+                const message = (_.get(err, "code") === "ENOENT" ? `${Cli.CF_CMD}: command not found` : _.get(err, "message"));
+                resolve({ stdout: stdout, stderr: stderr, error: message, exitCode: types_1.CF_CMD_EXIT_CODE.ERROR });
+            });
+            token.onCancellationRequested(() => {
+                childProcess.kill();
+                Cli.cliResultOnExit("", resolve, "", types_1.CF_CMD_EXIT_CODE.CANCELED);
+            });
+        });
+    }
+    static cliResultOnExit(stdout, resolve, stderr, code) {
+        if (stdout) {
+            if (stdout.indexOf("error_code") > 0) {
+                try {
+                    const cfErr = (0, comment_json_1.parse)(stdout);
+                    const message = (_.get(cfErr, "code") === 10002 ? Cli.CF_LOGIN_ERROR : _.get(cfErr, "description", "Internal error occured"));
+                    resolve({ stdout: stdout, stderr: stderr, exitCode: types_1.CF_CMD_EXIT_CODE.ERROR, error: message });
+                    return;
+                }
+                catch (e) {
+                }
+            }
+            else if (stdout.startsWith("FAILED") && stdout.indexOf("Error creating request") > 0) {
+                resolve({ stdout: stdout, stderr: stderr, error: Cli.CF_LOGIN_ERROR, exitCode: types_1.CF_CMD_EXIT_CODE.ERROR });
+                return;
+            }
+            else if (/failed.*\bError\b:/g.test(stdout)) {
+                try {
+                    (0, comment_json_1.parse)(stdout);
+                }
+                catch (e) {
+                    resolve({ stdout: stdout, stderr: stderr, error: stdout, exitCode: types_1.CF_CMD_EXIT_CODE.ERROR });
+                    return;
+                }
+            }
+            else if (stdout.startsWith("FAILED") && stdout.indexOf("No API endpoint set") > 0) {
+                resolve({ stdout: stdout, stderr: stderr, error: stdout, exitCode: types_1.CF_CMD_EXIT_CODE.ERROR });
+                return;
+            }
+        }
+        resolve({ stdout: stdout, stderr: stderr, exitCode: code });
+    }
+    static updateSpawnOptions(options) {
+        if (options) {
+            options.env = Object.assign(Object.assign(Object.assign({}, process.env), { NODE_VERSION: process.versions.node }), options.env);
+            _.defaults(options, { cwd: _.get(options, "cmd", __dirname) });
+        }
+    }
+}
+exports.Cli = Cli;
+Cli.CF_LOGIN_ERROR = "Not logged in. Use 'cf login' to log in.";
+Cli.CF_CMD = "cf";
+//# sourceMappingURL=cli.js.map

package/out/src/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./types";
+export * from "./cli";
+export * from "./cf-local";
+export * from "./messages";
+export * from "./utils";
+import { ServiceInstanceInfo } from "./types";
+export declare function apiGetServicesInstancesFilteredByType(serviceTypes: string[]): Promise<ServiceInstanceInfo[]>;
+export declare function apiGetInstanceCredentials(instanceName: string): Promise<any>;
+export declare function apiCreateServiceInstance(serviceType: string, servicePlan: string, instanceName: string, config?: any): Promise<any>;
+export declare function apiGetInstanceMetadata(instanceName: string): Promise<any>;

package/out/src/index.js

@@ -0,0 +1,40 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiGetInstanceMetadata = exports.apiCreateServiceInstance = exports.apiGetInstanceCredentials = exports.apiGetServicesInstancesFilteredByType = void 0;
+__exportStar(require("./types"), exports);
+__exportStar(require("./cli"), exports);
+__exportStar(require("./cf-local"), exports);
+__exportStar(require("./messages"), exports);
+__exportStar(require("./utils"), exports);
+const serviceUtils = require("./cfServicesUtil");
+async function apiGetServicesInstancesFilteredByType(serviceTypes) {
+    return serviceUtils.getServicesInstancesFilteredByType(serviceTypes);
+}
+exports.apiGetServicesInstancesFilteredByType = apiGetServicesInstancesFilteredByType;
+async function apiGetInstanceCredentials(instanceName) {
+    return serviceUtils.getInstanceCredentials(instanceName);
+}
+exports.apiGetInstanceCredentials = apiGetInstanceCredentials;
+async function apiCreateServiceInstance(serviceType, servicePlan, instanceName, config) {
+    return serviceUtils.createServiceInstance(serviceType, servicePlan, instanceName, config);
+}
+exports.apiCreateServiceInstance = apiCreateServiceInstance;
+async function apiGetInstanceMetadata(instanceName) {
+    return serviceUtils.getInstanceMetadata(instanceName);
+}
+exports.apiGetInstanceMetadata = apiGetInstanceMetadata;
+//# sourceMappingURL=index.js.map

package/out/src/messages.d.ts

@@ -0,0 +1,12 @@
+export declare const messages: {
+    space_not_set: string;
+    service_creation_started: string;
+    create_service_canceled_by_requester: string;
+    cf_setting_not_set: string;
+    no_valid_filters: string;
+    failed_creating_entity: (description: string, name: string) => string;
+    exceed_number_of_attempts: (name: string) => string;
+    service_not_found: (instanceName: string) => string;
+    service_creation_failed: (error: string) => string;
+    not_allowed_filter: (param: string, query: string) => string;
+};

package/out/src/messages.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.messages = void 0;
+exports.messages = {
+    space_not_set: `The selected action failed because there is no Cloud Foundry space assigned.`,
+    service_creation_started: `Service instance creation started, waiting for 'Ready' state...`,
+    create_service_canceled_by_requester: `The service instance creation was cancelled by the requester. The service may have been partially created, consider deleting it using the 'cf delete-service' command.`,
+    cf_setting_not_set: `Could not find the Cloud Foundry settings. Make sure you have assigned an org and space in Cloud Foundry.`,
+    no_valid_filters: `Could not find any valid filters.`,
+    failed_creating_entity: (description, name) => `Could not create the entity since ${description}, consider deleting it using the 'cf delete-service ${name} command'.`,
+    exceed_number_of_attempts: (name) => `Could not verify the service instance creation. Check its status using the 'cf service ${name}' command.`,
+    service_not_found: (instanceName) => `Could not find the '${instanceName}' service instance.`,
+    service_creation_failed: (error) => `Service instance creation failed: ${error}`,
+    not_allowed_filter: (param, query) => `The '${param}' parameter is not allowed in the '${query}' query.`,
+};
+//# sourceMappingURL=messages.js.map

package/out/src/task.d.ts

@@ -0,0 +1 @@
+export declare function saveTaskConfiguration(wsFolderPath: string, configuration: any): Promise<void>;

package/out/src/task.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveTaskConfiguration = void 0;
+const fs = require("fs");
+const path = require("path");
+const _ = require("lodash");
+const comment_json_1 = require("comment-json");
+const DEFAULT_TASKS_JSON_CONTENT = { version: "2.0.0", tasks: [] };
+async function getTaskJsonContentAsJsonObject(taskJsonFilePath) {
+    try {
+        const tasksJsonString = await fs.promises.readFile(taskJsonFilePath, { encoding: "utf8" });
+        const tasksJson = (0, comment_json_1.parse)(tasksJsonString);
+        return _.assign(DEFAULT_TASKS_JSON_CONTENT, tasksJson);
+    }
+    catch (e) {
+        return DEFAULT_TASKS_JSON_CONTENT;
+    }
+}
+async function saveTaskConfiguration(wsFolderPath, configuration) {
+    const taskJsonFilePath = path.join(wsFolderPath, ".vscode", "tasks.json");
+    const tasksJson = await getTaskJsonContentAsJsonObject(taskJsonFilePath);
+    const existingTaskindex = tasksJson.tasks.findIndex((task) => task.label === configuration.label);
+    if (existingTaskindex >= 0) {
+        tasksJson.tasks[existingTaskindex] = configuration;
+    }
+    else {
+        tasksJson.tasks.push(configuration);
+    }
+    await fs.promises.writeFile(taskJsonFilePath, (0, comment_json_1.stringify)(tasksJson, undefined, "  "));
+}
+exports.saveTaskConfiguration = saveTaskConfiguration;
+//# sourceMappingURL=task.js.map

package/out/src/types.d.ts

@@ -0,0 +1,214 @@
+export declare const OK = "OK";
+export declare const NEW_LINE = "\n";
+export declare const CF_PAGE_SIZE: number;
+export declare const DEFAULT_TARGET = "Default (no targets)";
+export interface CliResult {
+    stdout: string;
+    stderr: string;
+    error?: string;
+    exitCode: number;
+}
+export declare enum CF_CMD_EXIT_CODE {
+    OK = 0,
+    ERROR = -1,
+    CANCEL_REQ = -2,
+    CANCELED = -3
+}
+export interface CancellationToken {
+    isCancellationRequested: boolean;
+    onCancellationRequested: any;
+}
+interface Progress<T> {
+    report(value: T): void;
+}
+export interface ProgressHandler {
+    progress: Progress<{
+        message?: string;
+        increment?: number;
+    }>;
+    cancelToken: CancellationToken;
+}
+export interface CFTarget {
+    label: string;
+    isCurrent: boolean;
+    isDirty: boolean;
+}
+export interface ServiceInstanceInfo {
+    label: string;
+    serviceName: string;
+    guid?: string;
+    tags?: string[];
+    alwaysShow?: boolean;
+    plan_guid?: string;
+    plan?: string;
+    credentials?: any;
+}
+export interface ServiceInfo {
+    label: string;
+    guid: string;
+    service_plans_url: string;
+    description: string;
+}
+export interface PlanInfo {
+    label: string;
+    guid: string;
+    description: string;
+    service_offering?: {
+        guid: string;
+        name: string;
+        description: string;
+    };
+}
+export interface CFResource {
+    guid: string;
+    name: string;
+    description: string;
+    schemas: any;
+    relationships: any;
+    metadata: any;
+    links: any;
+}
+export interface ServiceTypeInfo {
+    name: string;
+    plan: string;
+    tag: string;
+    prompt: string;
+    plans?: PlanInfo[];
+    serviceKeyName?: string;
+    serviceKeyParam?: any;
+    ups?: {
+        tag?: string;
+        isShow?: boolean;
+    };
+    allowCreate?: {
+        serviceName?: string;
+        plan?: string;
+        tag?: string;
+        name?: string;
+        namePrompt?: string;
+        getParams?: () => Promise<any>;
+    };
+}
+export declare enum eFilters {
+    type = "type",
+    names = "names",
+    guids = "guids",
+    app_guids = "app_guids",
+    app_names = "app_names",
+    space_guids = "space_guids",
+    available = "available",
+    broker_catalog_ids = "broker_catalog_ids",
+    service_broker_guids = "service_broker_guids",
+    service_broker_names = "service_broker_names",
+    service_plan_guids = "service_plan_guids",
+    organization_guids = "organization_guids",
+    service_plan_names = "service_plan_names",
+    service_plan = "service_plan",
+    service_instance_guids = "service_instance_guids",
+    service_instance_names = "service_instance_names",
+    service_offering_guids = "service_offering_guids",
+    service_offering_names = "service_offering_names",
+    label_selector = "label_selector",
+    page = "page",
+    per_page = "per_page",
+    oder_by = "order_by",
+    created_ats = "created_ats",
+    updated_ats = "updated_ats",
+    status = "status",
+    include = "include"
+}
+export declare enum eOperation {
+    gte = "gte",
+    lte = "lte",
+    lt = "lt",
+    gt = "gt",
+    not = "not",
+    fields = "fields"
+}
+export interface IServiceFilters {
+    key: eFilters;
+    value: string;
+    op?: eOperation;
+}
+export declare enum eOrderDirection {
+    asc = 0,
+    desc = 1
+}
+export declare enum eServiceTypes {
+    managed = "managed",
+    user_provided = "user-provided"
+}
+export interface IServiceQuery {
+    filters?: IServiceFilters[];
+    per_page?: number;
+    page?: number;
+    order_by?: eOrderDirection;
+}
+export interface ServiceBinding {
+    env: string;
+    id: string;
+    type: string;
+    version: string;
+}
+export interface UAAInfo {
+    apiurl: string;
+    clientid: string;
+    clientsecret: string;
+    identityzone: string;
+    identityzoneid: string;
+    sburl: string;
+    tenantid: string;
+    tenantmode: string;
+    uaadomain: string;
+    url: string;
+    verificationkey: string;
+    xsappname: string;
+}
+export interface ServiceKey {
+    binding: ServiceBinding;
+    catalogs: any;
+    endpoints: any;
+    preserve_host_header: boolean;
+    "sap.cloud.service": string;
+    systemid: string;
+    uaa: UAAInfo;
+    url: string;
+}
+export interface Api {
+    "api endpoint": string;
+    "api version": string;
+}
+export interface ITarget extends Api {
+    user: string;
+    org?: string;
+    space?: string;
+}
+export interface UpsTypeInfo {
+    instanceName: string;
+    space_guid?: string;
+    syslog_drain_url?: string;
+    credentials?: unknown;
+    route_service_url?: string;
+    tags?: string[];
+}
+interface LoginOptions {
+    endpoint: string;
+    origin?: string;
+}
+export interface SSOLoginOptions extends LoginOptions {
+    ssoPasscode: string;
+}
+export interface CredentialsLoginOptions extends LoginOptions {
+    user: string;
+    password: string;
+}
+export interface Organization {
+    label: string;
+    guid: string;
+}
+export interface Space {
+    label: string;
+    guid: string;
+    orgGUID: string;
+}
+export {};

package/out/src/types.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eServiceTypes = exports.eOrderDirection = exports.eOperation = exports.eFilters = exports.CF_CMD_EXIT_CODE = exports.DEFAULT_TARGET = exports.CF_PAGE_SIZE = exports.NEW_LINE = exports.OK = void 0;
+exports.OK = "OK";
+exports.NEW_LINE = "\n";
+exports.CF_PAGE_SIZE = 99 * 3;
+exports.DEFAULT_TARGET = "Default (no targets)";
+var CF_CMD_EXIT_CODE;
+(function (CF_CMD_EXIT_CODE) {
+    CF_CMD_EXIT_CODE[CF_CMD_EXIT_CODE["OK"] = 0] = "OK";
+    CF_CMD_EXIT_CODE[CF_CMD_EXIT_CODE["ERROR"] = -1] = "ERROR";
+    CF_CMD_EXIT_CODE[CF_CMD_EXIT_CODE["CANCEL_REQ"] = -2] = "CANCEL_REQ";
+    CF_CMD_EXIT_CODE[CF_CMD_EXIT_CODE["CANCELED"] = -3] = "CANCELED";
+})(CF_CMD_EXIT_CODE = exports.CF_CMD_EXIT_CODE || (exports.CF_CMD_EXIT_CODE = {}));
+var eFilters;
+(function (eFilters) {
+    eFilters["type"] = "type";
+    eFilters["names"] = "names";
+    eFilters["guids"] = "guids";
+    eFilters["app_guids"] = "app_guids";
+    eFilters["app_names"] = "app_names";
+    eFilters["space_guids"] = "space_guids";
+    eFilters["available"] = "available";
+    eFilters["broker_catalog_ids"] = "broker_catalog_ids";
+    eFilters["service_broker_guids"] = "service_broker_guids";
+    eFilters["service_broker_names"] = "service_broker_names";
+    eFilters["service_plan_guids"] = "service_plan_guids";
+    eFilters["organization_guids"] = "organization_guids";
+    eFilters["service_plan_names"] = "service_plan_names";
+    eFilters["service_plan"] = "service_plan";
+    eFilters["service_instance_guids"] = "service_instance_guids";
+    eFilters["service_instance_names"] = "service_instance_names";
+    eFilters["service_offering_guids"] = "service_offering_guids";
+    eFilters["service_offering_names"] = "service_offering_names";
+    eFilters["label_selector"] = "label_selector";
+    eFilters["page"] = "page";
+    eFilters["per_page"] = "per_page";
+    eFilters["oder_by"] = "order_by";
+    eFilters["created_ats"] = "created_ats";
+    eFilters["updated_ats"] = "updated_ats";
+    eFilters["status"] = "status";
+    eFilters["include"] = "include";
+})(eFilters = exports.eFilters || (exports.eFilters = {}));
+var eOperation;
+(function (eOperation) {
+    eOperation["gte"] = "gte";
+    eOperation["lte"] = "lte";
+    eOperation["lt"] = "lt";
+    eOperation["gt"] = "gt";
+    eOperation["not"] = "not";
+    eOperation["fields"] = "fields";
+})(eOperation = exports.eOperation || (exports.eOperation = {}));
+var eOrderDirection;
+(function (eOrderDirection) {
+    eOrderDirection[eOrderDirection["asc"] = 0] = "asc";
+    eOrderDirection[eOrderDirection["desc"] = 1] = "desc";
+})(eOrderDirection = exports.eOrderDirection || (exports.eOrderDirection = {}));
+var eServiceTypes;
+(function (eServiceTypes) {
+    eServiceTypes["managed"] = "managed";
+    eServiceTypes["user_provided"] = "user-provided";
+})(eServiceTypes = exports.eServiceTypes || (exports.eServiceTypes = {}));
+//# sourceMappingURL=types.js.map

package/out/src/utils.d.ts

@@ -0,0 +1,18 @@
+import { IServiceQuery, IServiceFilters } from "./types";
+export declare function dataContentAsObject(filePath: string): Promise<any>;
+export declare function ensureQuery(query?: IServiceQuery): IServiceQuery;
+export declare function padQuery(query: IServiceQuery, otherFilters: IServiceFilters[]): IServiceQuery;
+export declare function getGuid(resource: any): string;
+export declare function getName(resource: any): string;
+export declare function getLabel(resource: any): string;
+export declare function getDescription(resource: any): string;
+export declare function getSpaceFieldGUID(spaceField: any): string;
+export declare function getOrgGUID(resource: any): string;
+export declare function getTags(resource: any): string[];
+export declare function cfGetConfigFilePath(target?: string): string;
+export declare function isUpsType(resource: any): boolean;
+export declare function cfGetConfigFileJson(target?: string): Promise<unknown>;
+export declare function cfGetConfigFileField(field: string, target?: string): Promise<any>;
+export declare function getSpaceGuidThrowIfUndefined(): Promise<string>;
+export declare function padQuerySpace(query: IServiceQuery, otherFilters?: IServiceFilters[]): Promise<IServiceQuery>;
+export declare function parseRawDictData(data: string): unknown;

package/out/src/utils.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRawDictData = exports.padQuerySpace = exports.getSpaceGuidThrowIfUndefined = exports.cfGetConfigFileField = exports.cfGetConfigFileJson = exports.isUpsType = exports.cfGetConfigFilePath = exports.getTags = exports.getOrgGUID = exports.getSpaceFieldGUID = exports.getDescription = exports.getLabel = exports.getName = exports.getGuid = exports.padQuery = exports.ensureQuery = exports.dataContentAsObject = void 0;
+const _ = require("lodash");
+const os = require("os");
+const fs = require("fs");
+const path = require("path");
+const comment_json_1 = require("comment-json");
+const messages_1 = require("./messages");
+const types_1 = require("./types");
+async function dataContentAsObject(filePath) {
+    try {
+        return _.reduce(_.split(await fs.promises.readFile(filePath, { encoding: "utf8" }), os.EOL), (data, line) => {
+            const parts = _.split(line, "=");
+            if (_.size(parts) > 1) {
+                data[_.trim(parts[0])] = _.trim(parts[1]);
+            }
+            return data;
+        }, {});
+    }
+    catch (error) {
+        return {};
+    }
+}
+exports.dataContentAsObject = dataContentAsObject;
+function ensureQuery(query) {
+    query = query || {};
+    _.defaults(query, { filters: [] });
+    _.defaults(query, { per_page: types_1.CF_PAGE_SIZE });
+    return query;
+}
+exports.ensureQuery = ensureQuery;
+function padQuery(query, otherFilters) {
+    query = ensureQuery(query);
+    _.each(otherFilters, (other) => {
+        const filter = _.find(query.filters, ["key", other.key]);
+        if (!_.size(filter === null || filter === void 0 ? void 0 : filter.value)) {
+            query.filters = _.concat(query.filters, [other]);
+        }
+    });
+    return query;
+}
+exports.padQuery = padQuery;
+function getGuid(resource) {
+    return _.get(resource, "guid", "");
+}
+exports.getGuid = getGuid;
+function getName(resource) {
+    return _.get(resource, "name", "");
+}
+exports.getName = getName;
+function getLabel(resource) {
+    return _.get(resource, "label", "");
+}
+exports.getLabel = getLabel;
+function getDescription(resource) {
+    return _.get(resource, "description", "");
+}
+exports.getDescription = getDescription;
+function getSpaceFieldGUID(spaceField) {
+    return _.get(spaceField, "GUID", "");
+}
+exports.getSpaceFieldGUID = getSpaceFieldGUID;
+function getOrgGUID(resource) {
+    return _.get(resource, ["relationships", "organization", "data", "guid"], "");
+}
+exports.getOrgGUID = getOrgGUID;
+function getTags(resource) {
+    return _.get(resource, "tags", []);
+}
+exports.getTags = getTags;
+function cfGetConfigFilePath(target) {
+    const relatives = target ? ["targets", `${target}.config.json`] : [`config.json`];
+    return path.join(_.get(process, "env.CF_HOME", os.homedir()), ".cf", ...relatives);
+}
+exports.cfGetConfigFilePath = cfGetConfigFilePath;
+function isUpsType(resource) {
+    return _.get(resource, "type", types_1.eServiceTypes.managed) === types_1.eServiceTypes.user_provided;
+}
+exports.isUpsType = isUpsType;
+async function cfGetConfigFileJson(target) {
+    try {
+        return (0, comment_json_1.parse)(await fs.promises.readFile(cfGetConfigFilePath(target), { encoding: "utf8" }));
+    }
+    catch (error) {
+    }
+}
+exports.cfGetConfigFileJson = cfGetConfigFileJson;
+async function cfGetConfigFileField(field, target) {
+    return _.get(await cfGetConfigFileJson(target), `${field}`);
+}
+exports.cfGetConfigFileField = cfGetConfigFileField;
+async function getSpaceGuidThrowIfUndefined() {
+    const space = getSpaceFieldGUID(await cfGetConfigFileField("SpaceFields"));
+    if (!space) {
+        throw new Error(messages_1.messages.cf_setting_not_set);
+    }
+    return space;
+}
+exports.getSpaceGuidThrowIfUndefined = getSpaceGuidThrowIfUndefined;
+async function padQuerySpace(query, otherFilters) {
+    query = padQuery(query, otherFilters);
+    const filter = _.find(query.filters, ["key", types_1.eFilters.space_guids]);
+    if (!_.size(filter === null || filter === void 0 ? void 0 : filter.value)) {
+        query.filters = _.concat(query.filters, [
+            { key: types_1.eFilters.space_guids, value: await getSpaceGuidThrowIfUndefined() },
+        ]);
+    }
+    return query;
+}
+exports.padQuerySpace = padQuerySpace;
+function parseRawDictData(data) {
+    const result = {};
+    _.each(_.compact(_.split(data, "\n")), (item) => {
+        item = _.replace(_.trim(item), /^['"]|['"]$/g, "");
+        const sep = _.indexOf(item, ":");
+        if (sep > -1) {
+            const key = _.toLower(_.trim(_.join(_.slice(item, 0, sep), "")));
+            const value = _.trim(_.join(_.slice(item, sep + 1), ""));
+            result[`${key}`] = value;
+        }
+    });
+    return result;
+}
+exports.parseRawDictData = parseRawDictData;
+//# sourceMappingURL=utils.js.map