@qoretechnologies/reqraft 0.1.0 → 0.2.0

package/__tests__/ mock.ts

@@ -0,0 +1,44 @@
+import { set } from 'lodash';
+
+export const storiesStorageMockEmpty = [
+  {
+    url: 'https://hq.qoretechnologies.com:8092/api/latest/users/_current_/storage',
+    method: 'GET',
+    status: 200,
+    response: {},
+  },
+];
+
+export const storiesStorageMock = [
+  {
+    url: 'https://hq.qoretechnologies.com:8092/api/latest/users/_current_/storage',
+    method: 'GET',
+    status: 200,
+    response: {
+      'sidebar-size': 350,
+      storybook: {
+        'some-path': 'This is a storage value',
+      },
+    },
+  },
+  {
+    url: 'https://hq.qoretechnologies.com:8092/api/latest/users/_current_/',
+    method: 'PUT',
+    status: 200,
+    response: (request) => {
+      const body = JSON.parse(request.body);
+
+      if (body.storage_path && !body.value) {
+        body.storage = {
+          'sidebar-size': 350,
+          storybook: {
+            'some-path': 'This is a NEW value',
+          },
+        };
+        set(body.storage, body.storage_path, null);
+      }
+
+      return body.storage;
+    },
+  },
+];

package/__tests__/utils.ts

@@ -0,0 +1,11 @@
+import { expect, screen, waitFor } from '@storybook/test';
+
+export const sleep = (ms: number) => {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+};
+
+export async function testsWaitForText(text: string, selector?: string) {
+  await waitFor(() => expect(screen.queryAllByText(text, { selector })[0]).toBeInTheDocument(), {
+    timeout: 10000,
+  });
+}

package/dist/__tests__/ mock.d.ts

@@ -0,0 +1,23 @@
+export declare const storiesStorageMockEmpty: {
+    url: string;
+    method: string;
+    status: number;
+    response: {};
+}[];
+export declare const storiesStorageMock: ({
+    url: string;
+    method: string;
+    status: number;
+    response: {
+        'sidebar-size': number;
+        storybook: {
+            'some-path': string;
+        };
+    };
+} | {
+    url: string;
+    method: string;
+    status: number;
+    response: (request: any) => any;
+})[];
+//# sourceMappingURL=%20mock.d.ts.map

package/dist/__tests__/ mock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":" mock.d.ts","sourceRoot":"","sources":["../../__tests__/ mock.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,uBAAuB;;;;;GAOnC,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;IAgC9B,CAAC"}

package/dist/__tests__/ mock.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storiesStorageMock = exports.storiesStorageMockEmpty = void 0;
+var lodash_1 = require("lodash");
+exports.storiesStorageMockEmpty = [
+    {
+        url: 'https://hq.qoretechnologies.com:8092/api/latest/users/_current_/storage',
+        method: 'GET',
+        status: 200,
+        response: {},
+    },
+];
+exports.storiesStorageMock = [
+    {
+        url: 'https://hq.qoretechnologies.com:8092/api/latest/users/_current_/storage',
+        method: 'GET',
+        status: 200,
+        response: {
+            'sidebar-size': 350,
+            storybook: {
+                'some-path': 'This is a storage value',
+            },
+        },
+    },
+    {
+        url: 'https://hq.qoretechnologies.com:8092/api/latest/users/_current_/',
+        method: 'PUT',
+        status: 200,
+        response: function (request) {
+            var body = JSON.parse(request.body);
+            if (body.storage_path && !body.value) {
+                body.storage = {
+                    'sidebar-size': 350,
+                    storybook: {
+                        'some-path': 'This is a NEW value',
+                    },
+                };
+                (0, lodash_1.set)(body.storage, body.storage_path, null);
+            }
+            return body.storage;
+        },
+    },
+];
+//# sourceMappingURL=%20mock.js.map

package/dist/__tests__/ mock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":" mock.js","sourceRoot":"","sources":["../../__tests__/ mock.ts"],"names":[],"mappings":";;;AAAA,iCAA6B;AAEhB,QAAA,uBAAuB,GAAG;IACrC;QACE,GAAG,EAAE,yEAAyE;QAC9E,MAAM,EAAE,KAAK;QACb,MAAM,EAAE,GAAG;QACX,QAAQ,EAAE,EAAE;KACb;CACF,CAAC;AAEW,QAAA,kBAAkB,GAAG;IAChC;QACE,GAAG,EAAE,yEAAyE;QAC9E,MAAM,EAAE,KAAK;QACb,MAAM,EAAE,GAAG;QACX,QAAQ,EAAE;YACR,cAAc,EAAE,GAAG;YACnB,SAAS,EAAE;gBACT,WAAW,EAAE,yBAAyB;aACvC;SACF;KACF;IACD;QACE,GAAG,EAAE,kEAAkE;QACvE,MAAM,EAAE,KAAK;QACb,MAAM,EAAE,GAAG;QACX,QAAQ,EAAE,UAAC,OAAO;YAChB,IAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YAEtC,IAAI,IAAI,CAAC,YAAY,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;gBACrC,IAAI,CAAC,OAAO,GAAG;oBACb,cAAc,EAAE,GAAG;oBACnB,SAAS,EAAE;wBACT,WAAW,EAAE,qBAAqB;qBACnC;iBACF,CAAC;gBACF,IAAA,YAAG,EAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC;YAC7C,CAAC;YAED,OAAO,IAAI,CAAC,OAAO,CAAC;QACtB,CAAC;KACF;CACF,CAAC"}

package/dist/__tests__/utils.d.ts

@@ -0,0 +1,3 @@
+export declare const sleep: (ms: number) => Promise<unknown>;
+export declare function testsWaitForText(text: string, selector?: string): Promise<void>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/__tests__/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../__tests__/utils.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,KAAK,OAAQ,MAAM,qBAE/B,CAAC;AAEF,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,iBAIrE"}

package/dist/__tests__/utils.js

@@ -0,0 +1,60 @@
+"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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testsWaitForText = exports.sleep = void 0;
+var test_1 = require("@storybook/test");
+var sleep = function (ms) {
+    return new Promise(function (resolve) { return setTimeout(resolve, ms); });
+};
+exports.sleep = sleep;
+function testsWaitForText(text, selector) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, test_1.waitFor)(function () { return (0, test_1.expect)(test_1.screen.queryAllByText(text, { selector: selector })[0]).toBeInTheDocument(); }, {
+                        timeout: 10000,
+                    })];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.testsWaitForText = testsWaitForText;
+//# sourceMappingURL=utils.js.map

package/dist/__tests__/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../__tests__/utils.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,wCAA0D;AAEnD,IAAM,KAAK,GAAG,UAAC,EAAU;IAC9B,OAAO,IAAI,OAAO,CAAC,UAAC,OAAO,IAAK,OAAA,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,EAAvB,CAAuB,CAAC,CAAC;AAC3D,CAAC,CAAC;AAFW,QAAA,KAAK,SAEhB;AAEF,SAAsB,gBAAgB,CAAC,IAAY,EAAE,QAAiB;;;;wBACpE,qBAAM,IAAA,cAAO,EAAC,cAAM,OAAA,IAAA,aAAM,EAAC,aAAM,CAAC,cAAc,CAAC,IAAI,EAAE,EAAE,QAAQ,UAAA,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,iBAAiB,EAAE,EAAxE,CAAwE,EAAE;wBAC5F,OAAO,EAAE,KAAK;qBACf,CAAC,EAAA;;oBAFF,SAEE,CAAC;;;;;CACJ;AAJD,4CAIC"}

package/dist/mock/interfaceCategories.json

@@ -0,0 +1,155 @@
+{
+    "fsm": {
+        "singular_display_name": "Qog",
+        "display_name": "Qogs",
+        "short_desc": "Qogs are no-code logic elements based on finite state machines; they can be used anywhere in Qorus as an alternative to coding",
+        "supports_code": false,
+        "url_root": "fsms",
+        "drafts": 2,
+        "items": 49
+    },
+    "connection": {
+        "singular_display_name": "Connection",
+        "display_name": "Connections",
+        "short_desc": "Connections to remote systems",
+        "supports_code": false,
+        "url_root": "connections",
+        "drafts": 0,
+        "items": 25
+    },
+    "class": {
+        "singular_display_name": "Class",
+        "display_name": "Classes",
+        "short_desc": "Classes that can be used in Qorus interface code",
+        "supports_code": true,
+        "url_root": "classes",
+        "drafts": 0,
+        "items": 192
+    },
+    "errors": {
+        "singular_display_name": "Error",
+        "display_name": "Errors",
+        "short_desc": "Workflow error set definitions",
+        "supports_code": false,
+        "url_root": "error-sets",
+        "drafts": 0,
+        "items": 14
+    },
+    "event": {
+        "singular_display_name": "Workflow Sync Event",
+        "display_name": "Workflow Sync Events",
+        "short_desc": "Workflow synchronization events",
+        "supports_code": false,
+        "url_root": "events",
+        "drafts": 0,
+        "items": 9
+    },
+    "group": {
+        "singular_display_name": "Interface Group",
+        "display_name": "Interface Groups",
+        "short_desc": "Interface groups allow interfaces to be enabled and disabled together as well as enabling views on interfaces to be restricted for certain users",
+        "supports_code": false,
+        "url_root": "groups",
+        "drafts": 0,
+        "items": 102
+    },
+    "job": {
+        "singular_display_name": "Scheduled Job",
+        "display_name": "Scheduled Jobs",
+        "short_desc": "Jobs execute logic on a user-defined schedule",
+        "supports_code": true,
+        "url_root": "jobs",
+        "drafts": 0,
+        "items": 91
+    },
+    "mapper": {
+        "singular_display_name": "Mapper",
+        "display_name": "Mappers",
+        "short_desc": "Mappers are visual data transformation elements",
+        "supports_code": false,
+        "url_root": "mappers",
+        "drafts": 0,
+        "items": 37
+    },
+    "mapper-code": {
+        "singular_display_name": "Mapper Code Object",
+        "display_name": "Mapper Code",
+        "short_desc": "Mapper code elements are classes with methods that can be directly used in mappers for complex data transformation logic",
+        "supports_code": true,
+        "url_root": "classes",
+        "drafts": 0,
+        "items": 3
+    },
+    "pipeline": {
+        "singular_display_name": "Data Pipeline",
+        "display_name": "Data Pipelines",
+        "short_desc": "Data pipelines enable large volumes of data to be processed efficiently",
+        "supports_code": false,
+        "url_root": "pipelines",
+        "drafts": 0,
+        "items": 15
+    },
+    "queue": {
+        "singular_display_name": "Asynchronous Step Queue",
+        "display_name": "Asynchronous Step Queues",
+        "short_desc": "Asynchronous step queues connect the front end to the back end of asynchronous workflow steps",
+        "supports_code": false,
+        "url_root": "queues",
+        "drafts": 0,
+        "items": 13
+    },
+    "service": {
+        "singular_display_name": "Service",
+        "display_name": "Services",
+        "short_desc": "Services are a top-level interfacing object in Qorus",
+        "supports_code": true,
+        "url_root": "services",
+        "drafts": 0,
+        "items": 117
+    },
+    "sla": {
+        "singular_display_name": "SLA",
+        "display_name": "SLAs",
+        "short_desc": "SLAs track technical performance metrics with business impact",
+        "supports_code": false,
+        "url_root": "slas",
+        "drafts": 0,
+        "items": 5
+    },
+    "step": {
+        "singular_display_name": "Step",
+        "display_name": "Steps",
+        "short_desc": "Steps are an atomic execution element in a workflow",
+        "supports_code": true,
+        "url_root": "steps",
+        "drafts": 0,
+        "items": 233
+    },
+    "type": {
+        "singular_display_name": "Type",
+        "display_name": "Types",
+        "short_desc": "Data types",
+        "supports_code": false,
+        "url_root": "types",
+        "drafts": 0,
+        "items": 97
+    },
+    "value-map": {
+        "singular_display_name": "Value Map",
+        "display_name": "Value Maps",
+        "short_desc": "Value maps provide simple mappings from one value to another",
+        "supports_code": false,
+        "url_root": "valuemaps",
+        "drafts": 0,
+        "items": 10
+    },
+    "workflow": {
+        "singular_display_name": "Workflow",
+        "display_name": "Workflows",
+        "short_desc": "Workflows are the primary stateful orchestration interface type in Qorus",
+        "supports_code": true,
+        "url_root": "workflows",
+        "drafts": 0,
+        "items": 112
+    }
+}

package/dist/mock/menu.d.ts

@@ -0,0 +1,70 @@
+import { IReqoreIconName } from '@qoretechnologies/reqore/dist/types/icons';
+import { TReqraftMenuItem } from '../src';
+export declare const interfaceIcons: Record<string, IReqoreIconName>;
+declare const _default: ({
+    label: string;
+    icon: string;
+    to: string;
+    activePaths: string[];
+    id: string;
+    as: string;
+    submenu: TReqraftMenuItem[];
+    divider?: undefined;
+    href?: undefined;
+} | {
+    divider: boolean;
+    label?: undefined;
+    icon?: undefined;
+    to?: undefined;
+    activePaths?: undefined;
+    id?: undefined;
+    as?: undefined;
+    submenu?: undefined;
+    href?: undefined;
+} | {
+    label: string;
+    icon: string;
+    href: string;
+    activePaths: string[];
+    id: string;
+    as: string;
+    to?: undefined;
+    submenu?: undefined;
+    divider?: undefined;
+} | {
+    label: string;
+    id: string;
+    icon: string;
+    submenu: {
+        label: string;
+        icon: string;
+        href: string;
+        activePaths: string[];
+        id: string;
+        as: string;
+    }[];
+    to?: undefined;
+    activePaths?: undefined;
+    as?: undefined;
+    divider?: undefined;
+    href?: undefined;
+} | {
+    label: string;
+    icon: string;
+    activePaths: string[];
+    id: string;
+    submenu: {
+        label: string;
+        icon: string;
+        href: string;
+        activePaths: string[];
+        id: string;
+        as: string;
+    }[];
+    to?: undefined;
+    as?: undefined;
+    divider?: undefined;
+    href?: undefined;
+})[];
+export default _default;
+//# sourceMappingURL=menu.d.ts.map

package/dist/mock/menu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu.d.ts","sourceRoot":"","sources":["../../mock/menu.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,2CAA2C,CAAC;AAE5E,OAAO,EAAE,gBAAgB,EAAE,MAAM,QAAQ,CAAC;AAG1C,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAsB1D,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEF,wBA+QE"}