hcloud-sdk 0.0.15 → 14.13.2

package/lib/service/mailer/internal/index.js

@@ -0,0 +1,64 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Base_1 = require("../../../Base");
+class MailerInternal extends Base_1.default {
+    constructor() {
+        super(...arguments);
+        /**
+         * Sends a new mail based on a mailjet template.
+         *
+         * THIS IS AN INTERNAL ENDPOINT AND CAN ONLY BE USED FROM BACKENDS WITHIN THE HCLOUD DEPLOYMENT
+         * @param mail MailjetMailDTO
+         */
+        this.sendMailMailjet = (mail) => __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.axios.post(this.getEndpoint("/v1/send/mailjet"), mail);
+            return resp.data;
+        });
+        /**
+         * Sends a new mail based on a mustache html body.
+         *
+         * THIS IS AN INTERNAL ENDPOINT AND CAN ONLY BE USED FROM BACKENDS WITHIN THE HCLOUD DEPLOYMENT
+         * @param mail TemplateMail
+         * @deprecated in favor of sendMailMailjet
+         */
+        this.sendMailMustache = (mail) => __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.axios.post(this.getEndpoint("/v1/send/mustache"), mail);
+            return resp.data;
+        });
+        /**
+         * Sends a new mail based on a html body.
+         *
+         * THIS IS AN INTERNAL ENDPOINT AND CAN ONLY BE USED FROM BACKENDS WITHIN THE HCLOUD DEPLOYMENT
+         * @param mail TemplateMail
+         * @deprecated in favor of sendMailMailjet
+         */
+        this.sendMailHtml = (mail) => __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.axios.post(this.getEndpoint("/v1/send/html"), mail);
+            return resp.data;
+        });
+        /**
+         * Sends a new mail based on an existing template.
+         *
+         * THIS IS AN INTERNAL ENDPOINT AND CAN ONLY BE USED FROM BACKENDS WITHIN THE HCLOUD DEPLOYMENT
+         * @param mail TemplateMail
+         * @deprecated in favor of sendMailMailjet
+         */
+        this.sendMailTemplate = (mail) => __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.axios.post(this.getEndpoint("/v1/send/template"), mail);
+            return resp.data;
+        });
+    }
+    getEndpoint(endpoint) {
+        return `${this.options.server}/api/mailer/internal${endpoint}`;
+    }
+}
+exports.default = MailerInternal;

package/lib/service/mothership/index.d.ts

@@ -0,0 +1,97 @@
+import { AxiosInstance } from "axios";
+import Base, { Options } from "../../Base";
+import { PaginatedResponse, SearchParams, Version } from "../../interfaces/global";
+import { Agent, TargetAgent } from "../../interfaces/mothership";
+type RecurrentInfo = Pick<Agent, "uptime" | "cpuUtilization" | "memoryUsed" | "status">;
+type HelloInfo = RecurrentInfo & {
+    nickname?: string;
+    bundleVersion: string;
+};
+export default class MothershipService extends Base {
+    constructor(options: Options, axios: AxiosInstance);
+    /**
+     * Requests the endpoint version
+     * @returns Version object
+     */
+    version: () => Promise<Version>;
+    /**
+     * Say hello as an agent to the mothership
+     *
+     * @param uuid Agent's UUID
+     * @param uuidSignature HMAC-SHA256 hash of the Agent's UUID using the Agent's secret as the key
+     * @param info Information about the agent's uuid, hardware and nickname
+     * @return an Agent object
+     */
+    hello: (uuid: string, uuidSignature: string, info: HelloInfo) => Promise<{
+        agent: Agent;
+        token: string;
+    }>;
+    /**
+     * Say hello again as an agent to the mothership.
+     *
+     * This call should only be made after an initial hello.
+     *
+     * The session token obtained in the hello endpoint must be used here. Use the setAuthToken method to do so.
+     *
+     * @param info Information about the agent's system resources.
+     * @return an Agent object
+     */
+    helloAgain: (info: RecurrentInfo) => Promise<Agent>;
+    /**
+     * Register an agent to the mothership.
+     *
+     * This call should only be made once per agent, not once per agent session.
+     *
+     * @param uuid UUID of the Agent
+     * @param info Information about the agent's hardware and nickname.
+     * @param publicKey the public key of the agent that will be used for cryptography. The agent should remember its private key.
+     * @return an object holding a secret encrypted with the public key. The agent must decrypt it using its private key in order to use the /hello endpoint.
+     */
+    register: (uuid: string, info: Pick<Agent, Exclude<keyof Agent, "uuid" | "createDate" | "modifyDate" | "_id" | "ip">>, publicKey: string | Buffer) => Promise<{
+        secret: string;
+    }>;
+    /**
+     * Connect to an organization.
+     *
+     * This call should only be made after an initial hello.
+     *
+     * The session token obtained in the hello endpoint must be used here. Use the setAuthToken method to do so.
+     *
+     * @param orgName Name of the organization
+     * @param memberToken JWT assigned to a member of the organization
+     * @param email Email of the user owner of the JWT
+     */
+    connect: (orgName: string, memberToken: string, email: string) => Promise<void>;
+    /**
+     * Disconnect from an organization.
+     *
+     * This call should only be made after an initial hello.
+     *
+     * The session token obtained in the hello endpoint must be used here. Use the setAuthToken method to do so.
+     *
+     * @param orgName Name of the organization
+     * @param email Email of the user
+     */
+    disconnect: (orgName: string, email: string) => Promise<void>;
+    /**
+     * Disconnect as a target.
+     *
+     * This call should only be made after an initial hello.
+     *
+     * The session token obtained in the hello endpoint must be used here. Use the setAuthToken method to do so.
+     *
+     * @param email Email of the target
+     */
+    disconnectTarget: (email: string) => Promise<void>;
+    /**
+     * Search among the available targets for a given organization.
+     *
+     * @param orgName Name of the organization
+     * @returns Object containing an array of retrieved agents and the total number of available found in the database (independent of limit and page)
+     */
+    searchAvailableTargets: ({ orgName, filters, sorting, limit, page, }: SearchParams & {
+        orgName: string;
+    }) => Promise<PaginatedResponse<TargetAgent>>;
+    protected getEndpoint(endpoint: string): string;
+}
+export {};

package/lib/service/mothership/index.js

@@ -0,0 +1,136 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Base_1 = require("../../Base");
+const paginatedResponseHelper_1 = require("../../helper/paginatedResponseHelper");
+const searchFilter_1 = require("../../helper/searchFilter");
+class MothershipService extends Base_1.default {
+    constructor(options, axios) {
+        super(options, axios);
+        /**
+         * Requests the endpoint version
+         * @returns Version object
+         */
+        this.version = () => __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.axios.get(this.getEndpoint("/v1/version"));
+            return resp.data;
+        });
+        /**
+         * Say hello as an agent to the mothership
+         *
+         * @param uuid Agent's UUID
+         * @param uuidSignature HMAC-SHA256 hash of the Agent's UUID using the Agent's secret as the key
+         * @param info Information about the agent's uuid, hardware and nickname
+         * @return an Agent object
+         */
+        this.hello = (uuid, uuidSignature, info) => __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.axios.post(this.getEndpoint("/v1/hello"), info, {
+                headers: {
+                    Authorization: `Bearer ${uuid}.${uuidSignature}`,
+                },
+            });
+            return { agent: resp.data, token: resp.headers.authorization };
+        });
+        /**
+         * Say hello again as an agent to the mothership.
+         *
+         * This call should only be made after an initial hello.
+         *
+         * The session token obtained in the hello endpoint must be used here. Use the setAuthToken method to do so.
+         *
+         * @param info Information about the agent's system resources.
+         * @return an Agent object
+         */
+        this.helloAgain = (info) => __awaiter(this, void 0, void 0, function* () {
+            const resp = yield this.axios.patch(this.getEndpoint("/v1/hello/again"), info);
+            return resp.data;
+        });
+        /**
+         * Register an agent to the mothership.
+         *
+         * This call should only be made once per agent, not once per agent session.
+         *
+         * @param uuid UUID of the Agent
+         * @param info Information about the agent's hardware and nickname.
+         * @param publicKey the public key of the agent that will be used for cryptography. The agent should remember its private key.
+         * @return an object holding a secret encrypted with the public key. The agent must decrypt it using its private key in order to use the /hello endpoint.
+         */
+        // eslint-disable-next-line complexity
+        this.register = (uuid, info, publicKey) => __awaiter(this, void 0, void 0, function* () {
+            if (typeof publicKey !== "string") {
+                publicKey = publicKey.toString("hex");
+            }
+            const resp = yield this.axios.post(this.getEndpoint("/v1/register"), Object.assign({ uuid, publicKey }, info));
+            return resp.data;
+        });
+        /**
+         * Connect to an organization.
+         *
+         * This call should only be made after an initial hello.
+         *
+         * The session token obtained in the hello endpoint must be used here. Use the setAuthToken method to do so.
+         *
+         * @param orgName Name of the organization
+         * @param memberToken JWT assigned to a member of the organization
+         * @param email Email of the user owner of the JWT
+         */
+        this.connect = (orgName, memberToken, email) => __awaiter(this, void 0, void 0, function* () {
+            yield this.axios.post(this.getEndpoint(`/v1/org/${orgName}/connect`), { memberToken, email });
+        });
+        /**
+         * Disconnect from an organization.
+         *
+         * This call should only be made after an initial hello.
+         *
+         * The session token obtained in the hello endpoint must be used here. Use the setAuthToken method to do so.
+         *
+         * @param orgName Name of the organization
+         * @param email Email of the user
+         */
+        this.disconnect = (orgName, email) => __awaiter(this, void 0, void 0, function* () {
+            yield this.axios.delete(this.getEndpoint(`/v1/org/${orgName}/connect/${email}`));
+        });
+        /**
+         * Disconnect as a target.
+         *
+         * This call should only be made after an initial hello.
+         *
+         * The session token obtained in the hello endpoint must be used here. Use the setAuthToken method to do so.
+         *
+         * @param email Email of the target
+         */
+        this.disconnectTarget = (email) => __awaiter(this, void 0, void 0, function* () {
+            yield this.axios.delete(this.getEndpoint(`/v1/connect/${email}`));
+        });
+        /**
+         * Search among the available targets for a given organization.
+         *
+         * @param orgName Name of the organization
+         * @returns Object containing an array of retrieved agents and the total number of available found in the database (independent of limit and page)
+         */
+        this.searchAvailableTargets = (_a) => __awaiter(this, [_a], void 0, function* ({ orgName, filters, sorting, limit = 25, page = 0, }) {
+            const filtersDTO = filters === null || filters === void 0 ? void 0 : filters.map((f) => {
+                return new searchFilter_1.SearchFilterDTO(f);
+            });
+            const resp = yield this.axios.post(this.getEndpoint(`/v1/org/${orgName}/connect/search`), {
+                filters: filtersDTO,
+                sorting,
+            }, {
+                params: { limit, page },
+            });
+            return (0, paginatedResponseHelper_1.createPaginatedResponse)(resp);
+        });
+    }
+    getEndpoint(endpoint) {
+        return `${this.options.server}/api/mothership${endpoint}`;
+    }
+}
+exports.default = MothershipService;

package/lib/service/nats/index.d.ts

@@ -0,0 +1,51 @@
+import { AxiosInstance } from "axios";
+import { Msg, NatsConnection, PublishOptions, RequestOptions, Subscription, SubscriptionOptions } from "nats";
+import Base, { Options } from "../../Base";
+import { NatsCallback, NatsMessageType, NatsObject, NatsObjectType, RawMsg } from "../../interfaces/nats";
+/**
+ * Connect and authenticate using email and jwt
+ *
+ * to use websocket from within node, forceWebsocket can be used.
+ * A websocket library is required to be pre-installed and needs to be set as global:
+ * import WebSocket from "ws";
+ * Object.assign(global, { WebSocket: WebSocket });
+ */
+type ConnectParamsJwt = {
+    email: string;
+    jwt: string;
+    servers?: string[];
+    debug?: boolean;
+    forceWebsocket?: boolean;
+};
+/**
+ * Connect and authenticate using username and password
+ * Can only be used with the CUSTOM_AUTH admin!
+ *
+ * to use websocket from within node, forceWebsocket can be used.
+ * A websocket library is required to be pre-installed and needs to be set as global:
+ * import WebSocket from "ws";
+ * Object.assign(global, { WebSocket: WebSocket });
+ */
+type ConnectParamsPassword = {
+    username: string;
+    password: string;
+    servers?: string[];
+    debug?: boolean;
+    forceWebsocket?: boolean;
+};
+declare class Nats extends Base {
+    private natsConnection;
+    private subMap;
+    private connection;
+    constructor(options: Options, axios: AxiosInstance);
+    connect(params: ConnectParamsJwt | ConnectParamsPassword): Promise<NatsConnection>;
+    getConnection: () => NatsConnection | undefined;
+    sub(subject: string, callback: NatsCallback, options?: SubscriptionOptions): Promise<Subscription>;
+    unsub(subject: string | Subscription): void;
+    publish(subject: string, type: NatsMessageType, objectType: NatsObjectType, object: NatsObject, options?: PublishOptions): void;
+    request(subject: string, type: NatsMessageType, objectType: NatsObjectType, object: unknown, options?: RequestOptions): void;
+    requestAndWaitForResponse(subject: string, type: NatsMessageType, objectType: NatsObjectType, object: unknown, options?: RequestOptions): Promise<Msg | undefined>;
+    respond(msg: Msg | RawMsg, data: unknown): void;
+    protected getEndpoint(endpoint: string): string;
+}
+export default Nats;

package/lib/service/nats/index.js

@@ -0,0 +1,138 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const nats_1 = require("nats");
+const nats_ws_1 = require("nats.ws");
+const Base_1 = require("../../Base");
+const isBrowser = typeof window !== "undefined";
+class Nats extends Base_1.default {
+    constructor(options, axios) {
+        super(options, axios);
+        this.subMap = [];
+        this.connection = isBrowser ? nats_ws_1.connect : nats_1.connect;
+        this.getConnection = () => {
+            return this.natsConnection;
+        };
+    }
+    // eslint-disable-next-line complexity
+    connect(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (params.forceWebsocket) {
+                this.connection = nats_ws_1.connect;
+            }
+            if (!params.servers) {
+                // set defaults if servers array is empty
+                if (isBrowser) {
+                    // default via traefik exposed servers
+                    params.servers = [this.getEndpoint("/v1/0"), this.getEndpoint("/v1/1"), this.getEndpoint("/v1/2")];
+                }
+                else {
+                    // default kubernetes internal servers
+                    params.servers = ["hcloud-nats-0.hcloud-nats:4222", "hcloud-nats-1.hcloud-nats:4222", "hcloud-nats-2.hcloud-nats:4222"];
+                }
+            }
+            this.natsConnection = yield this.connection({
+                debug: params.debug,
+                maxReconnectAttempts: -1,
+                servers: params.servers,
+                pingInterval: 55 * 1000, //ping every 55 seconds
+                user: params.email !== undefined ? params.email : params.username,
+                pass: params.jwt !== undefined ? params.jwt : params.password,
+            });
+            return this.natsConnection;
+        });
+    }
+    sub(subject, callback, options) {
+        var _a;
+        let delay = 0;
+        if (!this.getConnection() || ((_a = this.getConnection()) === null || _a === void 0 ? void 0 : _a.isClosed())) {
+            delay = 3000;
+        }
+        // add delay just in case the connection has not been established yet
+        return new Promise((resolve, reject) => {
+            const newOptions = Object.assign(Object.assign({}, options), { callback: (err, msg) => {
+                    if (err !== null) {
+                        try {
+                            callback(err);
+                        }
+                        catch (ignored) {
+                            // ignore callback errors
+                        }
+                        return;
+                    }
+                    let parsedData;
+                    try {
+                        const data = new TextDecoder("utf-8").decode(msg.data);
+                        parsedData = JSON.parse(data);
+                    }
+                    catch (e) {
+                        callback(e);
+                        return;
+                    }
+                    try {
+                        callback(null, parsedData, msg);
+                    }
+                    catch (ignored) {
+                        // ignore callback errors
+                    }
+                } });
+            setTimeout(() => {
+                var _a, _b;
+                if (!this.getConnection() || !((_a = this.getConnection()) === null || _a === void 0 ? void 0 : _a.isClosed)) {
+                    reject(new Error("connection not established, can not subscribe"));
+                }
+                const sub = (_b = this.getConnection()) === null || _b === void 0 ? void 0 : _b.subscribe(subject, newOptions);
+                if (sub) {
+                    this.subMap.push({ subject, sub: sub });
+                    return resolve(sub);
+                }
+                return reject(new Error("could not subscribe"));
+            }, delay);
+        });
+    }
+    unsub(subject) {
+        if (typeof subject === "string") {
+            this.subMap.forEach((s) => {
+                if (s.subject === subject) {
+                    s.sub.unsubscribe();
+                }
+            });
+        }
+        else {
+            subject === null || subject === void 0 ? void 0 : subject.unsubscribe();
+        }
+    }
+    publish(subject, type, objectType, object, options) {
+        var _a;
+        const data = new TextEncoder().encode(JSON.stringify({ type: type, objectType: objectType, object: object }));
+        (_a = this.getConnection()) === null || _a === void 0 ? void 0 : _a.publish(subject, data, options);
+    }
+    request(subject, type, objectType, object, options) {
+        var _a;
+        const data = new TextEncoder().encode(JSON.stringify({ type: type, objectType: objectType, object: object }));
+        (_a = this.getConnection()) === null || _a === void 0 ? void 0 : _a.request(subject, data, options);
+    }
+    requestAndWaitForResponse(subject, type, objectType, object, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const data = new TextEncoder().encode(JSON.stringify({ type: type, objectType: objectType, object: object }));
+            return ((_a = this.getConnection()) === null || _a === void 0 ? void 0 : _a.request(subject, data, options)) || undefined;
+        });
+    }
+    respond(msg, data) {
+        const encodedData = new TextEncoder().encode(JSON.stringify(data));
+        msg.respond(encodedData);
+    }
+    getEndpoint(endpoint) {
+        return `${this.options.server}/ws/nats${endpoint}`;
+    }
+}
+exports.default = Nats;

package/lib/utils/Types.d.ts

@@ -0,0 +1 @@
+export type Select<T, Mandatory extends keyof T, Optional extends keyof T> = Pick<T, Mandatory> & Partial<Pick<T, Optional>>;

package/lib/utils/Types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/utils/bouncer/features/Provider.d.ts

@@ -0,0 +1,16 @@
+import { BouncerContext, HcloudFeature } from "../../../interfaces/bouncer";
+export type BouncerProviderLogger = (featureName: string, defaultValue: boolean, result: boolean, context?: BouncerContext, feature?: HcloudFeature) => void;
+export declare class BouncerProvider {
+    private features;
+    private context?;
+    private logger?;
+    constructor(features: HcloudFeature[], context?: BouncerContext, logger?: BouncerProviderLogger);
+    isEnabled(featureName: string, defaultValue: boolean, context?: BouncerContext): boolean;
+    addFeature(feature: HcloudFeature): void;
+    setFeatures(features: HcloudFeature[]): void;
+    setContext(context: BouncerContext): void;
+    updateContext({ region, email, organization }: BouncerContext): void;
+    private doesMatchRegion;
+    private doesMatchUser;
+    private doesMatchOrganization;
+}

package/lib/utils/bouncer/features/Provider.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BouncerProvider = void 0;
+class BouncerProvider {
+    constructor(features, context, logger) {
+        this.features = features;
+        this.context = context;
+        this.logger = logger;
+    }
+    /* eslint-disable complexity */
+    isEnabled(featureName, defaultValue, context) {
+        const feature = this.features.find(f => f.feature.name === featureName);
+        let result = defaultValue;
+        if (feature) {
+            result =
+                feature.feature.enabled &&
+                    this.doesMatchOrganization(feature, context !== null && context !== void 0 ? context : this.context) &&
+                    this.doesMatchUser(feature, context !== null && context !== void 0 ? context : this.context) &&
+                    this.doesMatchRegion(feature, context !== null && context !== void 0 ? context : this.context);
+        }
+        if (this.logger) {
+            this.logger(featureName, defaultValue, result, context !== null && context !== void 0 ? context : this.context, feature);
+        }
+        return result;
+    }
+    addFeature(feature) {
+        this.features.push(feature);
+    }
+    setFeatures(features) {
+        this.features = features;
+    }
+    setContext(context) {
+        this.context = context;
+    }
+    updateContext({ region, email, organization }) {
+        if (!this.context) {
+            this.context = {
+                email,
+                organization,
+                region,
+            };
+        }
+        else {
+            this.context.email = email !== null && email !== void 0 ? email : this.context.email;
+            this.context.organization = organization !== null && organization !== void 0 ? organization : this.context.organization;
+            this.context.region = region !== null && region !== void 0 ? region : this.context.region;
+        }
+    }
+    /* eslint-disable @typescript-eslint/no-non-null-assertion*/
+    doesMatchRegion(feature, context) {
+        if (feature.regions.length) {
+            if (context === null || context === void 0 ? void 0 : context.region) {
+                return (feature.regions.map(r => r.replace("*", "(.+)")).find(r => r === (context === null || context === void 0 ? void 0 : context.region) || new RegExp(r).test(context.region)) !==
+                    undefined);
+            }
+            return false;
+        }
+        return true;
+    }
+    /* eslint-disable @typescript-eslint/no-non-null-assertion*/
+    doesMatchUser(feature, context) {
+        if (feature.users.length) {
+            if (context === null || context === void 0 ? void 0 : context.email) {
+                return (feature.users.map(u => u.replace("*", "(.+)")).find(u => u === context.email || new RegExp(u).test(context.email)) !== undefined);
+            }
+            return false;
+        }
+        return true;
+    }
+    /* eslint-disable @typescript-eslint/no-non-null-assertion*/
+    doesMatchOrganization(feature, context) {
+        if (feature.organizations.length) {
+            if (context === null || context === void 0 ? void 0 : context.organization) {
+                return (feature.organizations
+                    .map(o => o.replace("*", "(.+)"))
+                    .find(o => o === context.organization || new RegExp(o).test(context.organization)) !== undefined);
+            }
+            return false;
+        }
+        return true;
+    }
+}
+exports.BouncerProvider = BouncerProvider;