@trayio/tray-schema 0.12.0 → 0.14.0

package/README.md

@@ -0,0 +1,70 @@
+# Tray-schema
+This module contains a collection of utilities for transforming and manipulating various representations of Tray's connector schema.
+
+# TJSTraySchemaTypeTransformer
+
+## Overview
+This part of the module takes a CDK connectors input or output typescript type definitions, along with any JSdoc annotations, and generates JSON schema representing these types. Specifically this format is Tray schema, otherwise known as CAPI schema, but importantly it is not the old way of writing connector JSON schema, which is reffered to as the legacy connector schema.
+
+To generate the full schema for a connector this utility will be invoked for each operation's input and output. Operation metadata is pulled from the handler (using a different util) and then all of this schema is stiched together (using yet another different util) to produce the final connectors.json in Tray schema format. Which will then be transformed into legcay connector schema (by yet another different util) to ensure the connector works with the legacy deployment process.
+
+Have a look at the example types used for unit tests within `src/TJSTraySchemaTypeTransformer/tests/` for examples of how to do different things with typescript and JSdoc.
+
+## Why use NPM lib typescript-json-schema
+
+We found only 2 suitable libraries for converting typescript types to JSON schema:
+- typescript-json-schema:
+    - It's functionality cannot be extended
+    - It won't throw an exception if you ask it to generate "invalid" schema
+- ts-json-schema-generator
+    - Is an extension of typescript-json-schema
+    - It's functionality can be extended
+    - It will throw an exception if you ask it to generate "invalid" schema. And this is the main reason we did not chose this library, because this library sees some of the extra properties Tray schema has as invalid.
+
+## Post processing
+To get around the non extendable nature of the typescript-json-schema lib we perform a number of different post processing steps on the generated JSON schema.
+## Enums
+Tray schema supports enum labels so users can have a enum value which is sent and an enum label which is just displayed in the UI. Adding support for enum lables is trivial, until you realise that typescript-json-schema sorts the enums alphabetically. There are a few different ways to handle this, all of them are not ideal.
+
+You can force the user to specify their enum, enum labels and enum order, which is incredibley cumbersome, they would have to write the enum list 4 times (its 4 not 3 because a TS enum needs a key and value).
+
+For now we will not allow custom enum labels, instead we try to generate they best enum label possible automatically, in addition the order of enums can't be specified. We are planning on opening a PR to the typescript-json-schema lib to add a config option to disable this sorting. This way when we have this PR merged we can enable enum labels through the @enumLabel JSdoc annotation and it will be backwards compatible for end users.
+
+## Lookup / DDLs
+Ideally DDLs would be defined in JSdoc like this, using the dot to target the property in the resulting JSON schema (e.g. @lookup.operation). Unfortunately this doesn't work with the typescript-json-schema library. So instead we use camelCased annotation names (e.g. @lookupOperation) and then use post processing to rearrange the schema. Potentially we could also raise a PR to the lib to add this dot notation support.
+```
+// ideal input
+export type Input = {
+	/**
+	 * @lookup.operation list_users_actual_ddl
+	 * @lookup.input {"include_private_channels": false,"workspace_id": "{{{workspace_id}}}"}
+	 */
+	emails: string;
+};
+
+// actual input
+export type Input = {
+	/**
+	 * @lookupOperation list_users_actual_ddl
+	 * @lookupInput {"include_private_channels": false,"workspace_id": "{{{workspace_id}}}"}
+	 */
+	emails: string;
+};
+
+// Output
+emails: {
+    type: 'string',
+    lookup: {
+        operation: 'list_users_actual_ddl',
+        input: {
+            include_private_channels: false,
+            workspace_id: '{{{workspace_id}}}',
+        },
+    },
+},
+```
+
+## Advance fields not supported yet
+Some more work is required to support advanced fields, which is when a field is hidden within the Tray UI in an expandable advanced section.
+
+Would need to add a new JSdoc annotation @advanced, this will be added to each item of the schema though when it needs to be in an array, similar to how the required fields works. So post processing would be required to strip out the individual required: true on each item and combine them into an array at the parent item level.

package/dist/schema/TJSTraySchemaTypeTransformer.d.ts

@@ -0,0 +1,9 @@
+import * as TJS from 'typescript-json-schema';
+import { Either } from 'fp-ts/Either';
+import { DynamicObject } from '@trayio/tray-commons/dynamictype/DynamicType';
+import { TraySchemaTypeTransformer } from './TraySchemaTypeTransformer';
+export declare class TJSTraySchemaTypeTransformer implements TraySchemaTypeTransformer {
+    generateFromTypes(type: string, path: string): Either<Error, DynamicObject>;
+    jsonSchemaToTraySchema(schema: TJS.Definition): TJS.Definition;
+}
+//# sourceMappingURL=TJSTraySchemaTypeTransformer.d.ts.map

package/dist/schema/TJSTraySchemaTypeTransformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TJSTraySchemaTypeTransformer.d.ts","sourceRoot":"","sources":["../../src/schema/TJSTraySchemaTypeTransformer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,GAAG,MAAM,wBAAwB,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAe,MAAM,cAAc,CAAC;AAEnD,OAAO,EAAE,aAAa,EAAE,MAAM,8CAA8C,CAAC;AAC7E,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AAExE,qBAAa,4BAA6B,YAAW,yBAAyB;IAC7E,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,aAAa,CAAC;IAwB3E,sBAAsB,CAAC,MAAM,EAAE,GAAG,CAAC,UAAU,GAAG,GAAG,CAAC,UAAU;CAsF9D"}

package/dist/schema/TJSTraySchemaTypeTransformer.js

@@ -0,0 +1,135 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TJSTraySchemaTypeTransformer = void 0;
+const path_1 = require("path");
+const TJS = __importStar(require("typescript-json-schema"));
+const Either_1 = require("fp-ts/Either");
+const lodash_1 = require("lodash");
+class TJSTraySchemaTypeTransformer {
+    generateFromTypes(type, path) {
+        const settings = {
+            // this will prevent creating references in the schema when references are used in the types
+            ref: false,
+            // adds support for DDLs and more in the JSdoc annotations
+            validationKeywords: ['lookupInput', 'lookupOperation', 'enumLabels'],
+            // adds a required array to every entitiy in the schema which describes which children are required
+            required: true,
+        };
+        const compilerOptions = {
+            strictNullChecks: true,
+        };
+        const program = TJS.getProgramFromFiles([(0, path_1.resolve)(path)], compilerOptions);
+        const schema = TJS.generateSchema(program, type, settings);
+        if (schema !== null) {
+            const traySchema = this.jsonSchemaToTraySchema(schema);
+            return (0, Either_1.right)(traySchema);
+        }
+        return (0, Either_1.left)(new Error('Failed to generate JSON schema from type'));
+    }
+    jsonSchemaToTraySchema(schema) {
+        const transformLookup = (object) => {
+            if (object.lookupOperation && object.lookupInput) {
+                object.lookup = {
+                    operation: object.lookupOperation,
+                    input: object.lookupInput,
+                };
+                delete object.lookupOperation;
+                delete object.lookupInput;
+            }
+        };
+        const transformEnumLabels = (object) => {
+            if (object.enumLabels && typeof object.enumLabels === 'string') {
+                const enumLabelsString = object.enumLabels;
+                const enumLabelsArray = enumLabelsString.split(', ');
+                object.enumLabels = enumLabelsArray;
+            }
+        };
+        const generateEnumLabels = (object) => {
+            if (object.enum && Array.isArray(object.enum)) {
+                const enumLabels = [];
+                const enums = object.enum;
+                enums.forEach((enumItem) => {
+                    if (typeof enumItem === 'string') {
+                        enumLabels.push((0, lodash_1.startCase)((0, lodash_1.camelCase)(enumItem)));
+                    }
+                    else {
+                        enumLabels.push(enumItem.toString());
+                    }
+                });
+                object.enum = enums;
+                object.enumLabels = enumLabels;
+            }
+        };
+        const transformOneOf = (object) => {
+            if (object.anyOf) {
+                object.oneOf = object.anyOf;
+                delete object.anyOf;
+            }
+        };
+        const transformAllOf = (object) => {
+            if (object.allOf && Array.isArray(object.allOf)) {
+                object.allOf.forEach((part) => {
+                    // eslint-disable-next-line no-restricted-syntax
+                    for (const [key, value] of Object.entries(part)) {
+                        if (Array.isArray(value)) {
+                            if (!object[key]) {
+                                object[key] = value;
+                            }
+                            else {
+                                object[key] = [
+                                    ...object[key],
+                                    ...value,
+                                ];
+                            }
+                        }
+                        else if (typeof value === 'object' && value !== null) {
+                            object[key] = Object.assign(Object.assign({}, object[key]), value);
+                        }
+                        else {
+                            object[key] = value;
+                        }
+                    }
+                });
+                delete object.allOf;
+            }
+        };
+        const recursiveObjectSearch = (object) => {
+            transformAllOf(object);
+            // eslint-disable-next-line no-restricted-syntax
+            for (const [key, value] of Object.entries(object)) {
+                if (typeof value === 'object' && value !== null) {
+                    transformLookup(value);
+                    generateEnumLabels(value);
+                    transformOneOf(value);
+                    recursiveObjectSearch(value);
+                }
+            }
+        };
+        recursiveObjectSearch(schema);
+        return schema;
+    }
+}
+exports.TJSTraySchemaTypeTransformer = TJSTraySchemaTypeTransformer;

package/dist/schema/TJSTraySchemaTypeTransformer.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=TJSTraySchemaTypeTransformer.test.d.ts.map

package/dist/schema/TJSTraySchemaTypeTransformer.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TJSTraySchemaTypeTransformer.test.d.ts","sourceRoot":"","sources":["../../src/schema/TJSTraySchemaTypeTransformer.test.ts"],"names":[],"mappings":""}

package/dist/schema/TJSTraySchemaTypeTransformer.test.js

@@ -0,0 +1,290 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const E = __importStar(require("fp-ts/Either"));
+const path_1 = require("path");
+const TJSTraySchemaTypeTransformer_1 = require("./TJSTraySchemaTypeTransformer");
+describe('TJSTraySchemaTypeTransformer', () => {
+    it('Generates data types', () => {
+        const type = 'Input';
+        const dirPath = __dirname;
+        const path = (0, path_1.join)(dirPath, 'datatypes.test.data.ts');
+        const result = new TJSTraySchemaTypeTransformer_1.TJSTraySchemaTypeTransformer().generateFromTypes(type, path);
+        const actual = E.getOrElse((error) => {
+            console.warn(error);
+            throw new Error(`Failed to generate JSON schema from type`);
+        })(result);
+        const expected = {
+            type: 'object',
+            properties: {
+                str: { type: 'string' },
+                num: { type: 'number' },
+                int: { type: 'integer' },
+                bool: { type: 'boolean' },
+                obj: { type: 'object', properties: {}, additionalProperties: true },
+                arr: {
+                    type: 'array',
+                    items: { type: 'object', properties: {}, additionalProperties: true },
+                },
+            },
+            required: ['arr', 'bool', 'int', 'num', 'obj', 'str'],
+            $schema: 'http://json-schema.org/draft-07/schema#',
+        };
+        expect(actual).toEqual(expected);
+    });
+    it('Generates reusable parts of the schema by importing types and using typescript intersections', () => {
+        const type = 'Input';
+        const dirPath = __dirname;
+        const path = (0, path_1.join)(dirPath, 'importsReusable.test.data.ts');
+        const result = new TJSTraySchemaTypeTransformer_1.TJSTraySchemaTypeTransformer().generateFromTypes(type, path);
+        const actual = E.getOrElse((error) => {
+            console.warn(error);
+            throw new Error(`Failed to generate JSON schema from type`);
+        })(result);
+        const expected = {
+            type: 'object',
+            properties: {
+                specificField: { type: 'string' },
+                reusableFields: {
+                    type: 'object',
+                    properties: {
+                        reusableFieldA: { type: 'number' },
+                        reusableFieldB: { type: 'string' },
+                    },
+                    required: ['reusableFieldA', 'reusableFieldB'],
+                },
+                reusableSchemaA: { type: 'number' },
+                reusableSchemaB: { type: 'string' },
+            },
+            required: [
+                'reusableFields',
+                'specificField',
+                'reusableSchemaA',
+                'reusableSchemaB',
+            ],
+            $schema: 'http://json-schema.org/draft-07/schema#',
+        };
+        expect(actual).toEqual(expected);
+    });
+    it('Generates oneOfs and nested oneOfs from typescript union types by converting anyOfs during post processing', () => {
+        const type = 'Input';
+        const dirPath = __dirname;
+        const path = (0, path_1.join)(dirPath, 'oneOf.test.data.ts');
+        const result = new TJSTraySchemaTypeTransformer_1.TJSTraySchemaTypeTransformer().generateFromTypes(type, path);
+        const actual = E.getOrElse((error) => {
+            console.warn(error);
+            throw new Error(`Failed to generate JSON schema from type`);
+        })(result);
+        const expected = {
+            type: 'object',
+            properties: {
+                elements: {
+                    title: 'Elements',
+                    description: 'Add images or text to the context. Maximum number of items is 10.',
+                    type: 'array',
+                    items: {
+                        oneOf: [
+                            {
+                                type: 'object',
+                                properties: {
+                                    src: {
+                                        oneOf: [
+                                            {
+                                                type: 'object',
+                                                properties: {
+                                                    path: { type: 'string' },
+                                                    metadata: { type: 'string' },
+                                                },
+                                                required: ['metadata', 'path'],
+                                            },
+                                            {
+                                                type: 'object',
+                                                properties: { imgId: { type: 'number' } },
+                                                required: ['imgId'],
+                                            },
+                                        ],
+                                    },
+                                },
+                                required: ['src'],
+                            },
+                            {
+                                type: 'object',
+                                properties: {
+                                    msg: {
+                                        title: 'myText',
+                                        description: 'the text.',
+                                        type: 'string',
+                                    },
+                                },
+                                required: ['msg'],
+                            },
+                        ],
+                    },
+                },
+            },
+            required: ['elements'],
+            $schema: 'http://json-schema.org/draft-07/schema#',
+        };
+        expect(actual).toEqual(expected);
+    });
+    it('Generates enums and enumLabels', () => {
+        const type = 'Input';
+        const dirPath = __dirname;
+        const path = (0, path_1.join)(dirPath, 'enum.test.data.ts');
+        const result = new TJSTraySchemaTypeTransformer_1.TJSTraySchemaTypeTransformer().generateFromTypes(type, path);
+        const actual = E.getOrElse((error) => {
+            console.warn(error);
+            throw new Error(`Failed to generate JSON schema from type`);
+        })(result);
+        const expected = {
+            type: 'object',
+            properties: {
+                actions: {
+                    description: 'example dropdown',
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            text: { type: 'string' },
+                            type: {
+                                enumLabels: ['Default Always', 'Primary One', 'The Danger'],
+                                enum: ['default always', 'primary-one', 'the_danger'],
+                                type: 'string',
+                            },
+                        },
+                        required: ['text', 'type'],
+                    },
+                },
+            },
+            required: ['actions'],
+            $schema: 'http://json-schema.org/draft-07/schema#',
+        };
+        expect(actual).toEqual(expected);
+    });
+    it('Generates DDL lookup format during post processing', () => {
+        const type = 'Input';
+        const dirPath = __dirname;
+        const path = (0, path_1.join)(dirPath, 'ddl.test.data.ts');
+        const result = new TJSTraySchemaTypeTransformer_1.TJSTraySchemaTypeTransformer().generateFromTypes(type, path);
+        const actual = E.getOrElse((error) => {
+            console.warn(error);
+            throw new Error(`Failed to generate JSON schema from type`);
+        })(result);
+        const expected = {
+            type: 'object',
+            properties: {
+                emails: {
+                    type: 'string',
+                    lookup: {
+                        operation: 'list_users_actual_ddl',
+                        input: {
+                            include_private_channels: false,
+                            workspace_id: '{{{workspace_id}}}',
+                        },
+                    },
+                },
+            },
+            required: ['emails'],
+            $schema: 'http://json-schema.org/draft-07/schema#',
+        };
+        expect(actual).toEqual(expected);
+    });
+    it('Generates required fields array based on typescripts optional (?) symbol', () => {
+        const type = 'Input';
+        const dirPath = __dirname;
+        const path = (0, path_1.join)(dirPath, 'required.test.data.ts');
+        const result = new TJSTraySchemaTypeTransformer_1.TJSTraySchemaTypeTransformer().generateFromTypes(type, path);
+        const actual = E.getOrElse((error) => {
+            console.warn(error);
+            throw new Error(`Failed to generate JSON schema from type`);
+        })(result);
+        const expected = {
+            type: 'object',
+            properties: {
+                mandatoryField: { type: 'string' },
+                optionalField: { type: 'string' },
+            },
+            required: ['mandatoryField'],
+            $schema: 'http://json-schema.org/draft-07/schema#',
+        };
+        expect(actual).toEqual(expected);
+    });
+    it('Generates format properties from JSdoc annotations', () => {
+        const type = 'Input';
+        const dirPath = __dirname;
+        const path = (0, path_1.join)(dirPath, 'format.test.data.ts');
+        const result = new TJSTraySchemaTypeTransformer_1.TJSTraySchemaTypeTransformer().generateFromTypes(type, path);
+        const actual = E.getOrElse((error) => {
+            console.warn(error);
+            throw new Error(`Failed to generate JSON schema from type`);
+        })(result);
+        const expected = {
+            type: 'object',
+            properties: {
+                timestamp: { format: 'datetime', type: 'string' },
+                html: { format: 'code', type: 'string' },
+                longNotes: { format: 'text', type: 'string' },
+                password: { format: 'password', type: 'string' },
+                file: { format: 'file', type: 'string' },
+            },
+            required: ['file', 'html', 'longNotes', 'password', 'timestamp'],
+            $schema: 'http://json-schema.org/draft-07/schema#',
+        };
+        expect(actual).toEqual(expected);
+    });
+    it('Generates default properties from JSdoc annotations', () => {
+        const type = 'Input';
+        const dirPath = __dirname;
+        const path = (0, path_1.join)(dirPath, 'default.test.data.ts');
+        const result = new TJSTraySchemaTypeTransformer_1.TJSTraySchemaTypeTransformer().generateFromTypes(type, path);
+        const actual = E.getOrElse((error) => {
+            console.warn(error);
+            throw new Error(`Failed to generate JSON schema from type`);
+        })(result);
+        const expected = {
+            type: 'object',
+            properties: {
+                str: { default: 'string default', type: 'string' },
+                num: { default: 0.1, type: 'number' },
+                int: { type: 'integer', default: 1 },
+                bool: { default: true, type: 'boolean' },
+                obj: {
+                    default: { default: true },
+                    type: 'object',
+                    properties: {},
+                    additionalProperties: true,
+                },
+                arr: {
+                    default: ['default'],
+                    type: 'array',
+                    items: { type: 'object', properties: {}, additionalProperties: true },
+                },
+            },
+            required: ['arr', 'bool', 'int', 'num', 'obj', 'str'],
+            $schema: 'http://json-schema.org/draft-07/schema#',
+        };
+        expect(actual).toEqual(expected);
+    });
+});

package/dist/schema/TraySchemaTypeTransformer.d.ts

@@ -0,0 +1,6 @@
+import { Either } from 'fp-ts/lib/Either';
+import { DynamicObject } from '@trayio/tray-commons/dynamictype/DynamicType';
+export interface TraySchemaTypeTransformer {
+    generateFromTypes(type: string, path: string): Either<Error, DynamicObject>;
+}
+//# sourceMappingURL=TraySchemaTypeTransformer.d.ts.map

package/dist/schema/TraySchemaTypeTransformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TraySchemaTypeTransformer.d.ts","sourceRoot":"","sources":["../../src/schema/TraySchemaTypeTransformer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,8CAA8C,CAAC;AAE7E,MAAM,WAAW,yBAAyB;IACzC,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC;CAC5E"}

package/dist/schema/TraySchemaTypeTransformer.js

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

package/dist/schema/dataTypes.test.data.d.ts

@@ -0,0 +1,12 @@
+export declare type Input = {
+    str: string;
+    num: number;
+    /**
+     * @TJS-type integer
+     */
+    int: number;
+    bool: boolean;
+    obj: object;
+    arr: object[];
+};
+//# sourceMappingURL=dataTypes.test.data.d.ts.map

package/dist/schema/dataTypes.test.data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataTypes.test.data.d.ts","sourceRoot":"","sources":["../../src/schema/dataTypes.test.data.ts"],"names":[],"mappings":"AAAA,oBAAY,KAAK,GAAG;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,OAAO,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,EAAE,CAAC;CACd,CAAC"}

package/dist/schema/dataTypes.test.data.js

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

package/dist/schema/ddl.test.data.d.ts

@@ -0,0 +1,8 @@
+export declare type Input = {
+    /**
+     * @lookupOperation list_users_actual_ddl
+     * @lookupInput {"include_private_channels": false,"workspace_id": "{{{workspace_id}}}"}
+     */
+    emails: string;
+};
+//# sourceMappingURL=ddl.test.data.d.ts.map

package/dist/schema/ddl.test.data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ddl.test.data.d.ts","sourceRoot":"","sources":["../../src/schema/ddl.test.data.ts"],"names":[],"mappings":"AAAA,oBAAY,KAAK,GAAG;IACnB;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;CACf,CAAC"}

package/dist/schema/ddl.test.data.js

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

package/dist/schema/default.test.data.d.ts

@@ -0,0 +1,28 @@
+export declare type Input = {
+    /**
+     * @default string default
+     */
+    str: string;
+    /**
+     * @default 0.1
+     */
+    num: number;
+    /**
+     * @TJS-type integer
+     * @default 1
+     */
+    int: number;
+    /**
+     * @default true
+     */
+    bool: boolean;
+    /**
+     * @default { "default": true }
+     */
+    obj: object;
+    /**
+     * @default ["default"]
+     */
+    arr: object[];
+};
+//# sourceMappingURL=default.test.data.d.ts.map

package/dist/schema/default.test.data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default.test.data.d.ts","sourceRoot":"","sources":["../../src/schema/default.test.data.ts"],"names":[],"mappings":"AAAA,oBAAY,KAAK,GAAG;IACnB;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ;;;OAGG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ;;OAEG;IACH,IAAI,EAAE,OAAO,CAAC;IACd;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ;;OAEG;IACH,GAAG,EAAE,MAAM,EAAE,CAAC;CACd,CAAC"}

package/dist/schema/default.test.data.js

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

package/dist/schema/enum.test.data.d.ts

@@ -0,0 +1,17 @@
+export declare type Input = {
+    /**
+     * @description example dropdown
+     */
+    actions: Action[];
+};
+declare type Action = {
+    text: string;
+    type: ActionType;
+};
+declare enum ActionType {
+    default = "default always",
+    danger = "the_danger",
+    primary = "primary-one"
+}
+export {};
+//# sourceMappingURL=enum.test.data.d.ts.map

package/dist/schema/enum.test.data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum.test.data.d.ts","sourceRoot":"","sources":["../../src/schema/enum.test.data.ts"],"names":[],"mappings":"AAAA,oBAAY,KAAK,GAAG;IACnB;;OAEG;IACH,OAAO,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,aAAK,MAAM,GAAG;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,UAAU,CAAC;CACjB,CAAC;AAEF,aAAK,UAAU;IACd,OAAO,mBAAmB;IAC1B,MAAM,eAAe;IACrB,OAAO,gBAAgB;CACvB"}

package/dist/schema/enum.test.data.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var ActionType;
+(function (ActionType) {
+    ActionType["default"] = "default always";
+    ActionType["danger"] = "the_danger";
+    ActionType["primary"] = "primary-one";
+})(ActionType || (ActionType = {}));

package/dist/schema/format.test.data.d.ts

@@ -0,0 +1,23 @@
+export declare type Input = {
+    /**
+     * @format datetime
+     */
+    timestamp: string;
+    /**
+     * @format code
+     */
+    html: string;
+    /**
+     * @format text
+     */
+    longNotes: string;
+    /**
+     * @format password
+     */
+    password: string;
+    /**
+     * @format file
+     */
+    file: string;
+};
+//# sourceMappingURL=format.test.data.d.ts.map

package/dist/schema/format.test.data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.test.data.d.ts","sourceRoot":"","sources":["../../src/schema/format.test.data.ts"],"names":[],"mappings":"AAAA,oBAAY,KAAK,GAAG;IACnB;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;CACb,CAAC"}

package/dist/schema/format.test.data.js

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

package/dist/schema/importsReusable.test.data.d.ts

@@ -0,0 +1,9 @@
+import { ReusableField } from './reusableField.test.data';
+import { ReusableSchema } from './reusableSchema.test.data';
+export declare type Input = SpecificSchema & ReusableSchema;
+declare type SpecificSchema = {
+    specificField: string;
+    reusableFields: ReusableField;
+};
+export {};
+//# sourceMappingURL=importsReusable.test.data.d.ts.map

package/dist/schema/importsReusable.test.data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"importsReusable.test.data.d.ts","sourceRoot":"","sources":["../../src/schema/importsReusable.test.data.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAE5D,oBAAY,KAAK,GAAG,cAAc,GAAG,cAAc,CAAC;AAEpD,aAAK,cAAc,GAAG;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,aAAa,CAAC;CAC9B,CAAC"}

package/dist/schema/importsReusable.test.data.js

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

package/dist/schema/oneOf.test.data.d.ts

@@ -0,0 +1,28 @@
+declare type Src = {
+    path: string;
+    metadata: string;
+};
+declare type Id = {
+    imgId: number;
+};
+declare type SrcOrId = Src | Id;
+declare type Image = {
+    src: SrcOrId;
+};
+declare type Text = {
+    /**
+     * @title myText
+     * @description the text.
+     */
+    msg: string;
+};
+declare type ImageOrText = Image | Text;
+export declare type Input = {
+    /**
+     * @title Elements
+     * @description Add images or text to the context. Maximum number of items is 10.
+     */
+    elements: ImageOrText[];
+};
+export {};
+//# sourceMappingURL=oneOf.test.data.d.ts.map

package/dist/schema/oneOf.test.data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oneOf.test.data.d.ts","sourceRoot":"","sources":["../../src/schema/oneOf.test.data.ts"],"names":[],"mappings":"AAAA,aAAK,GAAG,GAAG;IACV,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,aAAK,EAAE,GAAG;IACT,KAAK,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,aAAK,OAAO,GAAG,GAAG,GAAG,EAAE,CAAC;AAExB,aAAK,KAAK,GAAG;IACZ,GAAG,EAAE,OAAO,CAAC;CACb,CAAC;AAEF,aAAK,IAAI,GAAG;IACX;;;OAGG;IACH,GAAG,EAAE,MAAM,CAAC;CACZ,CAAC;AAEF,aAAK,WAAW,GAAG,KAAK,GAAG,IAAI,CAAC;AAEhC,oBAAY,KAAK,GAAG;IACnB;;;OAGG;IACH,QAAQ,EAAE,WAAW,EAAE,CAAC;CACxB,CAAC"}

package/dist/schema/oneOf.test.data.js

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

package/dist/schema/required.test.data.d.ts

@@ -0,0 +1,5 @@
+export declare type Input = {
+    mandatoryField: string;
+    optionalField?: string;
+};
+//# sourceMappingURL=required.test.data.d.ts.map

package/dist/schema/required.test.data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"required.test.data.d.ts","sourceRoot":"","sources":["../../src/schema/required.test.data.ts"],"names":[],"mappings":"AAAA,oBAAY,KAAK,GAAG;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC"}

package/dist/schema/required.test.data.js

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

package/dist/schema/reusableField.test.data.d.ts

@@ -0,0 +1,5 @@
+export declare type ReusableField = {
+    reusableFieldA: number;
+    reusableFieldB: string;
+};
+//# sourceMappingURL=reusableField.test.data.d.ts.map

package/dist/schema/reusableField.test.data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reusableField.test.data.d.ts","sourceRoot":"","sources":["../../src/schema/reusableField.test.data.ts"],"names":[],"mappings":"AAAA,oBAAY,aAAa,GAAG;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;CACvB,CAAC"}

package/dist/schema/reusableField.test.data.js

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

package/dist/schema/reusableSchema.test.data.d.ts

@@ -0,0 +1,5 @@
+export declare type ReusableSchema = {
+    reusableSchemaA: number;
+    reusableSchemaB: string;
+};
+//# sourceMappingURL=reusableSchema.test.data.d.ts.map

package/dist/schema/reusableSchema.test.data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reusableSchema.test.data.d.ts","sourceRoot":"","sources":["../../src/schema/reusableSchema.test.data.ts"],"names":[],"mappings":"AAAA,oBAAY,cAAc,GAAG;IAC5B,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;CACxB,CAAC"}

package/dist/schema/reusableSchema.test.data.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trayio/tray-schema",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "Vanilla typescript code with extensions to the language or basic features",
   "exports": {
     "./*": "./dist/*.js"
@@ -8,8 +8,13 @@
   "author": "Tray.io",
   "license": "Proprietary",
   "dependencies": {
-    "@trayio/tray-commons": "0.12.0",
-    "@types/node": "*"
+    "@trayio/tray-commons": "0.14.0",
+    "@types/node": "*",
+    "lodash": "*",
+    "typescript-json-schema": "*"
+  },
+  "resolutions": {
+    "typescript-json-schema": "*"
   },
   "typesVersions": {
     "*": {