@flowcore/cli-plugin-iam 1.0.0

package/dist/utils/clients/iam/Transformers.js

@@ -0,0 +1,81 @@
+/* eslint-disable */
+/* tslint:disable */
+/*
+ * ---------------------------------------------------------------
+ * ## THIS FILE WAS GENERATED VIA SWAGGER-TYPESCRIPT-API        ##
+ * ##                                                           ##
+ * ## AUTHOR: acacode                                           ##
+ * ## SOURCE: https://github.com/acacode/swagger-typescript-api ##
+ * ---------------------------------------------------------------
+ */
+import { ContentType, HttpClient } from "./http-client.js";
+export class Transformers extends HttpClient {
+    /**
+     * No description
+     *
+     * @tags transformers
+     * @name PostTransformersIam0
+     * @request POST:/transformers/iam.0
+     * @secure
+     */
+    postTransformersIam0 = (data, params = {}) => this.request({
+        path: `/transformers/iam.0`,
+        method: "POST",
+        body: data,
+        secure: true,
+        type: ContentType.Json,
+        format: "json",
+        ...params,
+    });
+    /**
+     * No description
+     *
+     * @tags transformers
+     * @name PostTransformersOrganization0
+     * @request POST:/transformers/organization.0
+     * @secure
+     */
+    postTransformersOrganization0 = (data, params = {}) => this.request({
+        path: `/transformers/organization.0`,
+        method: "POST",
+        body: data,
+        secure: true,
+        type: ContentType.Json,
+        format: "json",
+        ...params,
+    });
+    /**
+     * No description
+     *
+     * @tags transformers
+     * @name PostTransformersUser0
+     * @request POST:/transformers/user.0
+     * @secure
+     */
+    postTransformersUser0 = (data, params = {}) => this.request({
+        path: `/transformers/user.0`,
+        method: "POST",
+        body: data,
+        secure: true,
+        type: ContentType.Json,
+        format: "json",
+        ...params,
+    });
+    /**
+     * No description
+     *
+     * @tags transformers
+     * @name PostTransformersSecurity0
+     * @request POST:/transformers/security.0
+     * @secure
+     */
+    postTransformersSecurity0 = (data, params = {}) => this.request({
+        path: `/transformers/security.0`,
+        method: "POST",
+        body: data,
+        secure: true,
+        type: ContentType.Json,
+        format: "json",
+        ...params,
+    });
+}

package/dist/utils/clients/iam/http-client.d.ts

@@ -0,0 +1,59 @@
+export type QueryParamsType = Record<string | number, any>;
+export type ResponseFormat = keyof Omit<Body, "body" | "bodyUsed">;
+export interface FullRequestParams extends Omit<RequestInit, "body"> {
+    /** set parameter to `true` for call `securityWorker` for this request */
+    secure?: boolean;
+    /** request path */
+    path: string;
+    /** content type of request body */
+    type?: ContentType;
+    /** query params */
+    query?: QueryParamsType;
+    /** format of response (i.e. response.json() -> format: "json") */
+    format?: ResponseFormat;
+    /** request body */
+    body?: unknown;
+    /** base url */
+    baseUrl?: string;
+    /** request cancellation token */
+    cancelToken?: CancelToken;
+}
+export type RequestParams = Omit<FullRequestParams, "body" | "method" | "query" | "path">;
+export interface ApiConfig<SecurityDataType = unknown> {
+    baseUrl?: string;
+    baseApiParams?: Omit<RequestParams, "baseUrl" | "cancelToken" | "signal">;
+    securityWorker?: (securityData: SecurityDataType | null) => Promise<RequestParams | void> | RequestParams | void;
+    customFetch?: typeof fetch;
+}
+export interface HttpResponse<D, E = unknown> extends Response {
+    data: D;
+    error: E;
+}
+type CancelToken = symbol | string | number;
+export declare enum ContentType {
+    Json = "application/json",
+    FormData = "multipart/form-data",
+    UrlEncoded = "application/x-www-form-urlencoded",
+    Text = "text/plain"
+}
+export declare class HttpClient<SecurityDataType = unknown> {
+    baseUrl: string;
+    private securityData;
+    private securityWorker?;
+    private abortControllers;
+    private customFetch;
+    private baseApiParams;
+    constructor(apiConfig?: ApiConfig<SecurityDataType>);
+    setSecurityData: (data: SecurityDataType | null) => void;
+    protected encodeQueryParam(key: string, value: any): string;
+    protected addQueryParam(query: QueryParamsType, key: string): string;
+    protected addArrayQueryParam(query: QueryParamsType, key: string): any;
+    protected toQueryString(rawQuery?: QueryParamsType): string;
+    protected addQueryParams(rawQuery?: QueryParamsType): string;
+    private contentFormatters;
+    protected mergeRequestParams(params1: RequestParams, params2?: RequestParams): RequestParams;
+    protected createAbortSignal: (cancelToken: CancelToken) => AbortSignal | undefined;
+    abortRequest: (cancelToken: CancelToken) => void;
+    request: <T = any, E = any>({ body, secure, path, type, query, format, baseUrl, cancelToken, ...params }: FullRequestParams) => Promise<HttpResponse<T, E>>;
+}
+export {};

package/dist/utils/clients/iam/http-client.js

@@ -0,0 +1,160 @@
+/* eslint-disable */
+/* tslint:disable */
+/*
+ * ---------------------------------------------------------------
+ * ## THIS FILE WAS GENERATED VIA SWAGGER-TYPESCRIPT-API        ##
+ * ##                                                           ##
+ * ## AUTHOR: acacode                                           ##
+ * ## SOURCE: https://github.com/acacode/swagger-typescript-api ##
+ * ---------------------------------------------------------------
+ */
+export var ContentType;
+(function (ContentType) {
+    ContentType["Json"] = "application/json";
+    ContentType["FormData"] = "multipart/form-data";
+    ContentType["UrlEncoded"] = "application/x-www-form-urlencoded";
+    ContentType["Text"] = "text/plain";
+})(ContentType || (ContentType = {}));
+export class HttpClient {
+    baseUrl = "https://iam.api.flowcore.io";
+    securityData = null;
+    securityWorker;
+    abortControllers = new Map();
+    customFetch = (...fetchParams) => fetch(...fetchParams);
+    baseApiParams = {
+        credentials: "same-origin",
+        headers: {},
+        redirect: "follow",
+        referrerPolicy: "no-referrer",
+    };
+    constructor(apiConfig = {}) {
+        Object.assign(this, apiConfig);
+    }
+    setSecurityData = (data) => {
+        this.securityData = data;
+    };
+    encodeQueryParam(key, value) {
+        const encodedKey = encodeURIComponent(key);
+        return `${encodedKey}=${encodeURIComponent(typeof value === "number" ? value : `${value}`)}`;
+    }
+    addQueryParam(query, key) {
+        return this.encodeQueryParam(key, query[key]);
+    }
+    addArrayQueryParam(query, key) {
+        const value = query[key];
+        return value.map((v) => this.encodeQueryParam(key, v)).join("&");
+    }
+    toQueryString(rawQuery) {
+        const query = rawQuery || {};
+        const keys = Object.keys(query).filter((key) => "undefined" !== typeof query[key]);
+        return keys
+            .map((key) => Array.isArray(query[key])
+            ? this.addArrayQueryParam(query, key)
+            : this.addQueryParam(query, key))
+            .join("&");
+    }
+    addQueryParams(rawQuery) {
+        const queryString = this.toQueryString(rawQuery);
+        return queryString ? `?${queryString}` : "";
+    }
+    contentFormatters = {
+        [ContentType.Json]: (input) => input !== null && (typeof input === "object" || typeof input === "string")
+            ? JSON.stringify(input)
+            : input,
+        [ContentType.Text]: (input) => input !== null && typeof input !== "string"
+            ? JSON.stringify(input)
+            : input,
+        [ContentType.FormData]: (input) => Object.keys(input || {}).reduce((formData, key) => {
+            const property = input[key];
+            formData.append(key, property instanceof Blob
+                ? property
+                : typeof property === "object" && property !== null
+                    ? JSON.stringify(property)
+                    : `${property}`);
+            return formData;
+        }, new FormData()),
+        [ContentType.UrlEncoded]: (input) => this.toQueryString(input),
+    };
+    mergeRequestParams(params1, params2) {
+        return {
+            ...this.baseApiParams,
+            ...params1,
+            ...(params2 || {}),
+            headers: {
+                ...(this.baseApiParams.headers || {}),
+                ...(params1.headers || {}),
+                ...((params2 && params2.headers) || {}),
+            },
+        };
+    }
+    createAbortSignal = (cancelToken) => {
+        if (this.abortControllers.has(cancelToken)) {
+            const abortController = this.abortControllers.get(cancelToken);
+            if (abortController) {
+                return abortController.signal;
+            }
+            return void 0;
+        }
+        const abortController = new AbortController();
+        this.abortControllers.set(cancelToken, abortController);
+        return abortController.signal;
+    };
+    abortRequest = (cancelToken) => {
+        const abortController = this.abortControllers.get(cancelToken);
+        if (abortController) {
+            abortController.abort();
+            this.abortControllers.delete(cancelToken);
+        }
+    };
+    request = async ({ body, secure, path, type, query, format, baseUrl, cancelToken, ...params }) => {
+        const secureParams = ((typeof secure === "boolean" ? secure : this.baseApiParams.secure) &&
+            this.securityWorker &&
+            (await this.securityWorker(this.securityData))) ||
+            {};
+        const requestParams = this.mergeRequestParams(params, secureParams);
+        const queryString = query && this.toQueryString(query);
+        const payloadFormatter = this.contentFormatters[type || ContentType.Json];
+        const responseFormat = format || requestParams.format;
+        return this.customFetch(`${baseUrl || this.baseUrl || ""}${path}${queryString ? `?${queryString}` : ""}`, {
+            ...requestParams,
+            headers: {
+                ...(requestParams.headers || {}),
+                ...(type && type !== ContentType.FormData
+                    ? { "Content-Type": type }
+                    : {}),
+            },
+            signal: (cancelToken
+                ? this.createAbortSignal(cancelToken)
+                : requestParams.signal) || null,
+            body: typeof body === "undefined" || body === null
+                ? null
+                : payloadFormatter(body),
+        }).then(async (response) => {
+            const r = response.clone();
+            r.data = null;
+            r.error = null;
+            const data = !responseFormat
+                ? r
+                : await response[responseFormat]()
+                    .then((data) => {
+                    if (r.ok) {
+                        r.data = data;
+                    }
+                    else {
+                        r.error = data;
+                    }
+                    return r;
+                })
+                    .catch((e) => {
+                    r.error = e;
+                    return r;
+                });
+            if (cancelToken) {
+                this.abortControllers.delete(cancelToken);
+            }
+            if (!response.ok)
+                throw data;
+            return data;
+        });
+    };
+}

package/dist/utils/combine-merge.util.d.ts

@@ -0,0 +1,2 @@
+import merge from 'deepmerge';
+export declare const combineMerge: (target: unknown[], source: unknown[], options: merge.ArrayMergeOptions) => unknown[];

package/dist/utils/combine-merge.util.js

@@ -0,0 +1,16 @@
+import merge from 'deepmerge';
+export const combineMerge = (target, source, options) => {
+    const destination = [...target];
+    for (const [index, item] of source.entries()) {
+        if (destination[index] === undefined) {
+            destination[index] = options.cloneUnlessOtherwiseSpecified(item, options);
+        }
+        else if (options.isMergeableObject(item)) {
+            destination[index] = merge(target[index], item, options);
+        }
+        else if (!target.includes(item)) {
+            destination.push(item);
+        }
+    }
+    return destination;
+};

package/dist/utils/fetch-manifest.util.d.ts

@@ -0,0 +1,6 @@
+export interface Parser<T> {
+    parse(raw: unknown): T;
+}
+export declare const FetchManifestUtil: {
+    fetchManifest<T>(files: string[], parser: Parser<T>): Promise<T>;
+};

package/dist/utils/fetch-manifest.util.js

@@ -0,0 +1,56 @@
+import { ux } from "@oclif/core";
+import merge from "deepmerge";
+import { load } from "js-yaml";
+import fs from "node:fs";
+import { combineMerge } from "./combine-merge.util.js";
+import { readPipe } from "./read-pipe.util.js";
+export const FetchManifestUtil = {
+    async fetchManifest(files, parser) {
+        const contents = [];
+        for (const file of files) {
+            if (file === "-") {
+                // eslint-disable-next-line no-await-in-loop
+                contents.push(await readPipe() || "");
+            }
+            else if (fs.existsSync(file)) {
+                contents.push(fs.readFileSync(file, "utf8"));
+            }
+            else {
+                ux.error(`File not found: ${file}`);
+            }
+        }
+        if (contents.length === 0) {
+            ux.error("No file content found");
+        }
+        let rawYaml;
+        for (const content of contents) {
+            try {
+                const parsed = load(content);
+                if (!parsed) {
+                    continue;
+                }
+                if (!rawYaml) {
+                    rawYaml = parsed;
+                    continue;
+                }
+                rawYaml = merge(rawYaml, parsed, {
+                    arrayMerge: combineMerge,
+                });
+            }
+            catch (error) {
+                ux.error(`Invalid YAML: ${error}`);
+            }
+        }
+        let yaml;
+        try {
+            yaml = parser.parse(rawYaml);
+        }
+        catch (error) {
+            ux.error(`Invalid YAML: ${error}`);
+        }
+        if (!yaml) {
+            ux.error("Invalid YAML");
+        }
+        return yaml;
+    },
+};

package/dist/utils/queries/fetch-organization-by-tenant.gql.d.ts

@@ -0,0 +1,14 @@
+export type FetchMyOrganizationsQueryResponse = {
+    me: {
+        id: string;
+        organizations: {
+            linkType: string;
+            organization: {
+                displayName: string;
+                id: string;
+                org: string;
+            };
+        }[];
+    };
+};
+export declare const FETCH_MY_ORGANIZATIONS_GQL_QUERY: string;

package/dist/utils/queries/fetch-organization-by-tenant.gql.js

@@ -0,0 +1,16 @@
+import { gql } from "graphql-request";
+export const FETCH_MY_ORGANIZATIONS_GQL_QUERY = gql `
+  query FLOWCORE_CLI_FETCH_MY_ORGANIZATIONS {
+    me {
+      id
+      organizations {
+        organization {
+          id
+          displayName
+          org
+        }
+        linkType
+      }
+    }
+  }
+`;

package/dist/utils/read-pipe.util.d.ts

@@ -0,0 +1 @@
+export declare const readPipe: () => Promise<string | undefined>;

package/dist/utils/read-pipe.util.js

@@ -0,0 +1,14 @@
+export const readPipe = () => new Promise(resolve => {
+    const stdin = process.openStdin();
+    stdin.setEncoding("utf8");
+    let data = '';
+    stdin.on('data', chunk => {
+        data += chunk;
+    });
+    stdin.on('end', () => {
+        resolve(data);
+    });
+    if (stdin.isTTY) {
+        resolve('');
+    }
+});

package/oclif.manifest.json

@@ -0,0 +1,127 @@
+{
+  "commands": {
+    "get:policy": {
+      "aliases": [],
+      "args": {
+        "NAME": {
+          "description": "name",
+          "name": "NAME",
+          "required": false
+        }
+      },
+      "description": "Get a policy",
+      "examples": [],
+      "flags": {
+        "profile": {
+          "description": "Specify the configuration profile to use",
+          "name": "profile",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "json": {
+          "char": "j",
+          "description": "json output",
+          "name": "json",
+          "required": false,
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "tenant": {
+          "char": "t",
+          "description": "tenant",
+          "name": "tenant",
+          "required": false,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "wide": {
+          "char": "w",
+          "description": "wide output",
+          "name": "wide",
+          "required": false,
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "get:policy",
+      "pluginAlias": "@flowcore/cli-plugin-iam",
+      "pluginName": "@flowcore/cli-plugin-iam",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "get",
+        "policy.js"
+      ]
+    },
+    "get:role": {
+      "aliases": [],
+      "args": {
+        "NAME": {
+          "description": "name",
+          "name": "NAME",
+          "required": false
+        }
+      },
+      "description": "Get a role",
+      "examples": [],
+      "flags": {
+        "profile": {
+          "description": "Specify the configuration profile to use",
+          "name": "profile",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "json": {
+          "char": "j",
+          "description": "json output",
+          "name": "json",
+          "required": false,
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "tenant": {
+          "char": "t",
+          "description": "tenant",
+          "name": "tenant",
+          "required": false,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "wide": {
+          "char": "w",
+          "description": "wide output",
+          "name": "wide",
+          "required": false,
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "get:role",
+      "pluginAlias": "@flowcore/cli-plugin-iam",
+      "pluginName": "@flowcore/cli-plugin-iam",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "get",
+        "role.js"
+      ]
+    }
+  },
+  "version": "1.0.0"
+}

package/package.json

@@ -0,0 +1,93 @@
+{
+	"author": "flowcore-platform",
+	"bin": {
+		"scenario": "./bin/run.js"
+	},
+	"dependencies": {
+		"@flowcore/cli-plugin-config": "^2.2.1",
+		"@flowcore/cli-plugin-core": "^4.0.3",
+		"@oclif/core": "^4.0.21",
+		"@oclif/plugin-help": "^6",
+		"@oclif/plugin-plugins": "^5.4.7",
+		"dayjs": "^1.11.10",
+		"deepmerge": "^4.3.1",
+		"enquirer": "^2.4.1",
+		"graphql": "^16.8.1",
+		"graphql-request": "^6.1.0",
+		"js-yaml": "^4.1.0",
+		"lodash": "^4.17.21",
+		"radash": "^12.1.0",
+		"uuid": "^9.0.1",
+		"zod": "^3.22.4"
+	},
+	"description": "Flowcore CLI plugin for managing the IAM of the Flowcore Platform",
+	"devDependencies": {
+		"@oclif/prettier-config": "^0.2.1",
+		"@oclif/test": "^4.0.9",
+		"@types/chai": "^4",
+		"@types/deepmerge": "^2.2.0",
+		"@types/js-yaml": "^4.0.9",
+		"@types/lodash": "^4.14.202",
+		"@types/mocha": "^10",
+		"@types/node": "^18",
+		"@types/uuid": "^9.0.8",
+		"chai": "^4",
+		"eslint": "^8",
+		"eslint-config-oclif": "^5",
+		"eslint-config-oclif-typescript": "^3",
+		"eslint-config-prettier": "^9.1.0",
+		"mocha": "^10",
+		"oclif": "^4.4.12",
+		"shx": "^0.3.4",
+		"ts-node": "^10.9.2",
+		"typescript": "5^"
+	},
+	"engines": {
+		"node": ">=18.0.0"
+	},
+	"files": [
+		"/bin",
+		"/dist",
+		"/oclif.manifest.json"
+	],
+	"homepage": "https://github.com/flowcore-io/cli-plugin-iam",
+	"license": "MIT",
+	"main": "",
+	"name": "@flowcore/cli-plugin-iam",
+	"oclif": {
+		"bin": "iam",
+		"dirname": "iam",
+		"commands": "./dist/commands",
+		"devPlugins": [
+			"@oclif/plugin-help",
+			"@oclif/plugin-plugins",
+			"@flowcore/cli-plugin-config"
+		],
+		"topicSeparator": " ",
+		"topics": {
+			"iam": {
+				"description": "Flowcore CLI plugin for managing the IAM of the Flowcore Platform"
+			}
+		}
+	},
+	"repository": "flowcore-io/cli-plugin-iam",
+	"scripts": {
+		"build": "shx rm -rf dist && tsc -b",
+		"lint": "eslint . --ext .ts",
+		"postpack": "shx rm -f oclif.manifest.json",
+		"posttest": "yarn run lint",
+		"prepack": "yarn run build && oclif manifest && oclif readme",
+		"prepare": "yarn run build",
+		"test": "mocha --forbid-only \"test/**/*.test.ts\"",
+		"version": "oclif readme && git add README.md",
+		"update-schema": "rover graph introspect https://graph.api.flowcore.io/graphql -o schema.gql"
+	},
+	"version": "1.0.0",
+	"bugs": "https://github.com/flowcore-io/cli-plugin-iam/issues",
+	"keywords": [
+		"oclif"
+	],
+	"types": "dist/index.d.ts",
+	"exports": "./dist/index.js",
+	"type": "module"
+}