@beseif-solutions/prow-core 0.0.39 → 0.2.0

package/dist/minified-utils/fields.js

@@ -3,23 +3,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extract = exports.validate = exports.fieldsSchema = exports.fieldSchema = void 0;
+exports.extract = exports.validate = exports.alter = exports.fieldsSchema = exports.fieldSchema = void 0;
 const joi_1 = __importDefault(require("joi"));
 const lodash_1 = __importDefault(require("lodash"));
 const moment_timezone_1 = __importDefault(require("moment-timezone"));
 const context_1 = __importDefault(require("./context"));
 const where_1 = require("./where");
 const conditionSchema = () => joi_1.default.object({
-    condition: joi_1.default.object(),
-    overrides: joi_1.default.object(),
-    show: joi_1.default.bool(),
-}).xor(`overrides`, `show`);
+    condition: joi_1.default.object().required(),
+    overrides: joi_1.default.object().required(),
+});
 const commonFieldSchema = () => joi_1.default.object({
     key: joi_1.default.string().required(),
     altered_by: joi_1.default.array().items(conditionSchema()),
     disabled: joi_1.default.bool(),
     required: joi_1.default.bool(),
     as_password: joi_1.default.bool(),
+    show: joi_1.default.bool(),
     show_label: joi_1.default.bool().default(true),
     as_array: joi_1.default.bool(),
     array_min: joi_1.default.when(`as_array`, {
@@ -77,12 +77,17 @@ const stringInputFieldSchema = () => joi_1.default.object({
     pattern: joi_1.default.string().valid(`email`, `uri`),
 })
     .concat(joi_1.default.object({
-    format: joi_1.default.string().valid(`select`, `textarea`, `rich-text`),
+    format: joi_1.default.string().valid(`select`, `textarea`, `rich-text`, `markdown`, `code`),
     choices: joi_1.default.when(`format`, {
         is: `select`,
         then: choicesSchema(joi_1.default.string()).required(),
         otherwise: joi_1.default.forbidden(),
     }),
+    language: joi_1.default.when(`format`, {
+        is: `code`,
+        then: joi_1.default.string(),
+        otherwise: joi_1.default.forbidden(),
+    }),
 }));
 const numberInputFieldSchema = () => joi_1.default.object({
     default: defaultSchema(joi_1.default.number()),
@@ -173,7 +178,7 @@ const fileReplacer = (field) => ({
         },
     ],
     default: field.default,
-    ...lodash_1.default.pick(field, [`altered_by`, `disabled`, `required`, `as_password`, `show_label`, `as_array`, `array_min`, `array_max`, `array_length`]),
+    ...lodash_1.default.pick(field, [`altered_by`, `disabled`, `required`, `as_password`, `show`, `show_label`, `as_array`, `array_min`, `array_max`, `array_length`]),
 });
 const fileInputFieldSchema = () => joi_1.default.object({
     default: defaultSchema(fileSchema()),
@@ -235,6 +240,9 @@ const getSimpleFieldSchema = (field) => {
     switch (field.type) {
         case `any`:
             typeSchema = anySchema();
+            if (field.allow_nullish) {
+                typeSchema = typeSchema.allow(null, ``, 0, undefined);
+            }
             break;
         case `boolean`:
             typeSchema = joi_1.default.bool();
@@ -303,11 +311,13 @@ const getSimpleFieldSchema = (field) => {
             if (field.max) {
                 typeSchema = typeSchema.max(field.max);
             }
-            if (field.float) {
-                typeSchema = typeSchema.precision(field.decimals || 2);
-            }
-            else {
-                typeSchema = typeSchema.precision(0);
+            if (typeof field.float === `boolean`) {
+                if (field.float) {
+                    typeSchema = typeSchema.precision(field.decimals || 2);
+                }
+                else {
+                    typeSchema = typeSchema.precision(0);
+                }
             }
             break;
         case `dict`:
@@ -366,10 +376,13 @@ const getObjectFieldSchema = (field, items) => {
     return getGeneralSchema(field, schema);
 };
 const getGeneralSchema = (field, schema) => {
+    if (field.required) {
+        schema = schema.required();
+    }
     if (field.disabled) {
         schema = schema.forbidden();
     }
-    return field.required ? schema.required() : schema;
+    return schema;
 };
 const convertPath = (parts) => parts.map((p, i) => typeof p === `string` ? (i === 0 ? p : `.${p}`) : `[${p}]`).join(``);
 const secure = async (field, validation) => field.as_password ? lodash_1.default.omit(validation, [`value`, `original`]) : validation;
@@ -389,9 +402,31 @@ const relative_condition = (condition, relative) => {
         throw e;
     }
 };
+const alter = (field, relative, data) => {
+    const cloned = lodash_1.default.cloneDeep(field);
+    for (const alteration of cloned.altered_by) {
+        const condition = relative_condition(alteration.condition, relative);
+        const matches = (0, where_1.where)(data, [condition]);
+        if (matches) {
+            lodash_1.default.assign(cloned, alteration.overrides);
+        }
+    }
+    return cloned;
+};
+exports.alter = alter;
 const recursive_schema = async (field, data, options) => {
     try {
-        const newField = field.type === `file` ? fileReplacer(field) : lodash_1.default.cloneDeep(field);
+        let newField = lodash_1.default.cloneDeep(field);
+        if (newField.altered_by?.length > 0) {
+            newField = (0, exports.alter)(newField, options.relative, data);
+            if (options.alter) {
+                delete newField.altered_by;
+            }
+        }
+        const alteredField = lodash_1.default.cloneDeep(newField);
+        if (newField.type === `file`) {
+            newField = fileReplacer(newField);
+        }
         const relativeKey = options.relative ?
             options.relative.endsWith(`]`) ?
                 options.array ? options.relative : `${options.relative}.${newField.key}`
@@ -405,7 +440,7 @@ const recursive_schema = async (field, data, options) => {
             const itemSchemas = [];
             if (lodash_1.default.isArray(resolved)) {
                 for (let i = 0; i < (resolved || []).length; i++) {
-                    const itemSchema = await recursive_schema(lodash_1.default.omit(newField, [`as_array`, `array_min`, `array_max`, `array_length`]), data, { relative: `${relativeKey}[${i}]`, array: true, context: options.context });
+                    const { schema: itemSchema } = await recursive_schema(lodash_1.default.omit(newField, [`as_array`, `array_min`, `array_max`, `array_length`]), data, { alter: false, relative: `${relativeKey}[${i}]`, array: true, context: options.context });
                     if (itemSchema) {
                         itemSchemas.push(itemSchema);
                     }
@@ -414,16 +449,17 @@ const recursive_schema = async (field, data, options) => {
             calculatedSchema = getArrayFieldSchema(newField, itemSchemas);
         }
         else if (newField.type === `dict` && newField.items) {
-            const itemSchemas = [];
+            const items = [];
             if (lodash_1.default.isObject(resolved)) {
                 for (const item of newField.items) {
-                    const itemSchema = await recursive_schema(item, data, { relative: relativeKey, context: options.context });
-                    if (itemSchema) {
-                        itemSchemas.push({ key: item.key, schema: itemSchema });
+                    const recursive = await recursive_schema(item, data, { alter: options.alter && true, relative: relativeKey, context: options.context });
+                    if (recursive) {
+                        items.push({ key: item.key, schema: recursive.schema, field: recursive.field });
                     }
                 }
             }
-            calculatedSchema = getObjectFieldSchema(newField, itemSchemas);
+            calculatedSchema = getObjectFieldSchema(newField, items);
+            newField.items = items.map((i) => i.field);
         }
         else {
             calculatedSchema = getSimpleFieldSchema(newField);
@@ -431,27 +467,14 @@ const recursive_schema = async (field, data, options) => {
         if (!calculatedSchema) {
             throw new Error(`Could not resolve schema for field ${newField.key}`);
         }
-        if (newField.altered_by?.length > 0) {
-            let hide = false;
-            for (const alteration of newField.altered_by) {
-                const condition = relative_condition(alteration.condition, options.relative);
-                const matches = (0, where_1.where)(data, [condition]);
-                if (matches) {
-                    if (`overrides` in alteration) {
-                        lodash_1.default.assign(newField, alteration.overrides);
-                    }
-                    else if (`show` in alteration) {
-                        hide = !alteration.show;
-                    }
-                }
-            }
-            delete newField.altered_by;
-            if (hide) {
-                lodash_1.default.unset(data, relativeKey);
-                return;
-            }
+        if (typeof newField.show === `boolean` && !newField.show) {
+            lodash_1.default.unset(data, relativeKey);
+            return;
+        }
+        else if (newField.disabled) {
+            lodash_1.default.unset(data, relativeKey);
         }
-        return calculatedSchema;
+        return { schema: calculatedSchema, field: field.type === `file` ? alteredField : newField };
     }
     catch (e) {
         throw e;
@@ -463,12 +486,15 @@ const validate_internal = async (fields, data, options) => {
         for (const field of fields) {
             const value = lodash_1.default.get(data, field.key, field.default);
             const cloned = lodash_1.default.cloneDeep(data);
-            const schema = await recursive_schema(field, cloned, { context: options.context });
+            const recursive = await recursive_schema(field, cloned, { alter: true, context: options.context });
+            if (!recursive) {
+                continue;
+            }
             const resolved = lodash_1.default.get(cloned, field.key, field.default);
             let validation;
             let error;
             try {
-                validation = await schema.validateAsync(resolved, { abortEarly: false });
+                validation = await recursive.schema.validateAsync(resolved, { abortEarly: false });
             }
             catch (e) {
                 error = e;
@@ -495,7 +521,7 @@ const validate_internal = async (fields, data, options) => {
             }
             response.valid && (response.valid = error ? false : true);
             response.fields.push({
-                ...field,
+                ...recursive.field,
                 ...options.secure ? await secure(field, extended) : extended,
             });
         }

package/dist/minified-utils/protocol.js

@@ -44,7 +44,7 @@ const localeListSchema = joi_1.default.object({
 }).required();
 const commandSchema = joi_1.default.alternatives(invokeSchema, credentialListSchema, actionListSchema, triggerListSchema, sourceListSchema, localeListSchema);
 const API_SOURCES = (provider, configuration, context) => ({
-    register: async (source, data) => {
+    register: async (source, sandbox, data) => {
         try {
             const { data: [created] } = await axios_1.default.post(`/api/v1/sources`, {
                 organization: context.organization,
@@ -52,6 +52,7 @@ const API_SOURCES = (provider, configuration, context) => ({
                 provider: provider.id,
                 version: provider.version,
                 source: source,
+                sandbox: sandbox,
                 data: data,
                 created_date: (0, moment_timezone_1.default)().format(`YYYY-MM-DDTHH:mm:ssZ`),
             }, {
@@ -69,7 +70,7 @@ const API_SOURCES = (provider, configuration, context) => ({
             throw e;
         }
     },
-    unregister: async (source, id) => {
+    unregister: async (source, sandbox, id) => {
         try {
             const { data: [get] } = await axios_1.default.post(`/api/v1/sources/list`, {
                 organization: context.organization,
@@ -77,6 +78,7 @@ const API_SOURCES = (provider, configuration, context) => ({
                 provider: provider.id,
                 version: provider.version,
                 source: source,
+                sandbox: sandbox,
                 uuid: id,
             }, {
                 baseURL: configuration.host,
@@ -98,7 +100,7 @@ const API_SOURCES = (provider, configuration, context) => ({
             throw e;
         }
     },
-    consume: async (source) => {
+    consume: async (source, sandbox) => {
         try {
             const { data: sources } = await axios_1.default.post(`/api/v1/sources/list`, {
                 organization: context.organization,
@@ -106,6 +108,7 @@ const API_SOURCES = (provider, configuration, context) => ({
                 provider: provider.id,
                 version: provider.version,
                 source: source,
+                sandbox: sandbox,
             }, {
                 baseURL: configuration.host,
                 headers: {

package/dist/minified-utils/types.d.ts

@@ -9,3 +9,4 @@ export type DeepPartial<T extends Record<string, any>> = {
     [P in keyof T]?: T[P] extends Record<string, any> ? DeepPartial<T[P]> : T[P];
 };
 export type AsyncReturnType<T extends (...args: any[]) => any> = T extends (...args: any[]) => Promise<infer U> ? U : T extends (...args: any[]) => infer U ? U : any;
+export type OneOrArray<T> = T | T[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@beseif-solutions/prow-core",
-  "version": "0.0.39",
+  "version": "0.2.0",
   "description": "Prow core functionalities and classes",
   "main": "dist/index.js",
   "scripts": {

package/src/core.ts

@@ -7,9 +7,9 @@ import { FromCatalog, FromDirectory, i18n, T } from "./minified-utils/locales";
 type SyncOrAsync<T> = T | Promise<T>;
 
 export type SourceFunctions = {
-  register: <T>(source: string, data: T) => SyncOrAsync<{ id: string }>,
-  consume: <T>(source: string) => SyncOrAsync<{ id: string, data: T }[]>,
-  unregister: (source: string, id: string) => SyncOrAsync<void>,
+  register: <T>(source: string, sandbox: boolean, data: T) => SyncOrAsync<{ id: string }>,
+  consume: <T>(source: string, sandbox: boolean) => SyncOrAsync<{ id: string, data: T }[]>,
+  unregister: (source: string, sandbox: boolean, id: string) => SyncOrAsync<void>,
 };
 
 const FALLBACK_SOURCES: SourceFunctions = {

package/src/entities/commons.ts

@@ -20,7 +20,7 @@ export type CoreFunction<Config extends CoreConfig = {}> = (core: Core, configur
     {} :
     { credentials: Config[`credentials`] }
   )
-)) => Promise<Config[`outputs`]>;
+)) => Promise<Config[`outputs`]> | Config[`outputs`];
 
 
 type CommonConfig = Pick<CoreConfig, `credentials`>;

package/src/entities/events.ts

@@ -1,6 +1,7 @@
 import Joi from "joi";
 import { Field, fieldsSchema } from "../minified-utils/fields";
 import { Common, commonSchema, CoreConfig, CoreFunction, idSchema } from "./commons";
+import { OneOrArray } from "../minified-utils/types";
 
 type CommonConnectableEvent<Keys extends string = string> = {
   key: Keys,
@@ -33,9 +34,18 @@ type EventConfig = Pick<CoreConfig, `credentials` | `outputs`> & {
     outputs: string[],
   },
   sources?: string[],
+  fields?: Record<string, any>,
 };
 
-type CommonEvents<Config extends EventConfig = {}> = Common<Config> & {
+type SetupEventConfig = EventConfig & {
+  setup?: Record<string, any>,
+};
+
+type MemoryEventConfig = EventConfig & {
+  memory?: Record<string, any>,
+};
+
+type CommonEvents<Config extends EventConfig = { fields: Record<string, any> }> = Common<Config> & {
   model: `event`,
   categorization: {
     department: string,
@@ -59,75 +69,116 @@ export type Request = {
   body: any,
 };
 
-export type ImmediateTrigger<Config extends EventConfig = {}> = CommonEvents<Config> & {
+export type ImmediateTrigger<Config extends SetupEventConfig = { fields: Record<string, any>, setup: Record<string, any> }> = CommonEvents<Config> & {
   type: `trigger`,
   immediate: true,
   outputs: [DefaultConnectableEvent<Config[`flags`][`outputs`][number]>],
   functions: {
     mount?: CoreFunction<{
       credentials: Config[`credentials`],
-      inputs: { fields: Record<string, any>, link: string },
-      outputs: { done: boolean, setup?: any },
+      inputs: { fields: Config[`fields`], link: string },
+      outputs: { done: boolean, setup?: Config[`setup`] },
     }>,
     unmount?: CoreFunction<{
       credentials: Config[`credentials`],
-      inputs: { fields: Record<string, any>, link: string, setup?: any },
+      inputs: { fields: Config[`fields`], link: string, setup?: Config[`setup`] },
       outputs: { done: boolean },
     }>,
     challenge?: CoreFunction<{
       credentials: Config[`credentials`],
-      inputs: { fields: Record<string, any>, link: string, request: Request, setup?: any },
+      inputs: { fields: Config[`fields`], link: string, request: Request, setup?: Config[`setup`] },
       outputs: { done: boolean, response?: any },
     }>,
     handle: CoreFunction<{
       credentials: Config[`credentials`],
-      inputs: { fields: Record<string, any>, request: Request, setup?: any },
+      inputs: { fields: Config[`fields`], request: Request, setup?: Config[`setup`] },
       outputs: { records: Config[`outputs`][], flags: Partial<Record<Config[`flags`][`outputs`][number], true>> },
     }>,
     fire?: CoreFunction<{
       credentials: Config[`credentials`],
-      inputs: { fields: Record<string, any>, link: string, setup?: any },
+      inputs: { fields: Config[`fields`], link: string, setup?: any },
       outputs: { done: boolean },
     }>,
     poll?: CoreFunction<{
       credentials: Config[`credentials`],
-      inputs: { fields: Record<string, any>, last_schedule?: string, limit?: number },
+      inputs: { fields: Config[`fields`], last_schedule?: string, limit?: number },
       outputs: { records: Config[`outputs`][], flags: Partial<Record<Config[`flags`][`outputs`][number], true>> },
     }>,
   },
 };
 
-export type ScheduledTrigger<Config extends EventConfig = {}> = CommonEvents<Config> & {
+export type ScheduledTrigger<Config extends EventConfig = { fields: Record<string, any> }> = CommonEvents<Config> & {
   type: `trigger`,
   immediate: false,
   outputs: [DefaultConnectableEvent<Config[`flags`][`outputs`][number]>],
   functions: {
     poll: CoreFunction<{
       credentials: Config[`credentials`],
-      inputs: { fields: Record<string, any>, last_schedule?: string, limit?: number },
+      inputs: { fields: Config[`fields`], last_schedule?: string, limit?: number },
       outputs: { records: Config[`outputs`][], flags: Partial<Record<Config[`flags`][`outputs`][number], true>> },
     }>,
   },
 };
 
-export type Trigger<Config extends EventConfig = {}> =
+export type Trigger<Config extends EventConfig = { fields: Record<string, any> }> =
   | ImmediateTrigger<Config>
   | ScheduledTrigger<Config>;
 
-export type Action<Config extends EventConfig = {}> = CommonEvents<Config> & {
+type StandardOutput<Config extends EventConfig> =
+  { output: OneOrArray<Config[`outputs`]>, flags: Partial<Record<Config[`flags`][`outputs`][number], true>> };
+
+type MemoryOutput<Config extends MemoryEventConfig = { memory: Record<string, any> }> = {
+  memory: Config[`memory`],
+} & (StandardOutput<Config> | {});
+
+export type Action<Config extends MemoryEventConfig = { fields: Record<string, any>, memory: Record<string, any> }> = CommonEvents<Config> & {
   type: `action`,
   inputs: [DefaultConnectableEvent<Config[`flags`][`inputs`][number]>, ...AdditionalConnectableEvent<Config[`flags`][`inputs`][number]>[]],
   outputs: [DefaultConnectableEvent<Config[`flags`][`outputs`][number]>, ...(AdditionalConnectableEvent<Config[`flags`][`outputs`][number]> | ErrorConnectableEvent<Config[`flags`][`outputs`][number]>)[]],
   functions: {
     execute: CoreFunction<{
       credentials: Config[`credentials`],
-      inputs: { fields: Record<string, any>, flags: Partial<Record<Config[`flags`][`inputs`][number], true>> },
-      outputs: { output: Config[`outputs`], flags: Partial<Record<Config[`flags`][`outputs`][number], true>> },
+      inputs: { fields: Config[`fields`], flags: Partial<Record<Config[`flags`][`inputs`][number], true>>, memory?: Config[`memory`] },
+      outputs: StandardOutput<Config> | MemoryOutput<Config>,
     }>,
   },
 };
 
-export type Event<Config extends EventConfig = {}> =
+export type AsyncAction<Config extends SetupEventConfig = { fields: Record<string, any>, setup: Record<string, any> }> = CommonEvents<Config> & {
+  type: `action`,
+  inputs: [DefaultConnectableEvent<Config[`flags`][`inputs`][number]>, ...AdditionalConnectableEvent<Config[`flags`][`inputs`][number]>[]],
+  outputs: [DefaultConnectableEvent<Config[`flags`][`outputs`][number]>, ...(AdditionalConnectableEvent<Config[`flags`][`outputs`][number]> | ErrorConnectableEvent<Config[`flags`][`outputs`][number]>)[]],
+  async: true,
+  functions: {
+    mount?: CoreFunction<{
+      credentials: Config[`credentials`],
+      inputs: { fields: Config[`fields`], link: string },
+      outputs: { done: boolean, setup?: Config[`setup`] },
+    }>,
+    unmount?: CoreFunction<{
+      credentials: Config[`credentials`],
+      inputs: { fields: Config[`fields`], link: string, setup?: Config[`setup`] },
+      outputs: { done: boolean },
+    }>,
+    execute: CoreFunction<{
+      credentials: Config[`credentials`],
+      inputs: { fields: Config[`fields`], flags: Partial<Record<Config[`flags`][`inputs`][number], true>>, setup?: Config[`setup`] },
+      outputs: { done: boolean, setup?: Config[`setup`] },
+    }>,
+    handle: CoreFunction<{
+      credentials: Config[`credentials`],
+      inputs: { fields: Config[`fields`], request: Request, setup?: Config[`setup`] },
+      outputs: StandardOutput<Config>,
+    }>,
+    fire?: CoreFunction<{
+      credentials: Config[`credentials`],
+      inputs: { fields: Config[`fields`], link: string, setup?: Config[`setup`] },
+      outputs: { done: boolean },
+    }>,
+  },
+};
+
+export type Event<Config extends EventConfig = { fields: Record<string, any> }> =
   | Action<Config>
   | Trigger<Config>;
 
@@ -218,7 +269,7 @@ export const immediateTriggerSchema = () =>
 export const triggerSchema = () =>
   Joi.alternatives(scheduledTriggerSchema(), immediateTriggerSchema());
 
-export const actionSchema = () =>
+export const syncActionSchema = () =>
   Joi.object({
     type: Joi.valid(`action`).required(),
     inputs: Joi.array()
@@ -243,6 +294,39 @@ export const actionSchema = () =>
     .concat(commonSchema())
     .concat(commonEventsSchema());
 
+export const asyncActionSchema = () =>
+  Joi.object({
+    type: Joi.valid(`action`).required(),
+    async: Joi.valid(true).required(),
+    inputs: Joi.array()
+      .items(
+        defaultConnectableEventSchema().required(),
+        additionalConnectableEventSchema(),
+      )
+      .min(1)
+      .required(),
+    outputs: Joi.array()
+      .items(
+        defaultConnectableEventSchema().required(),
+        errorConnectableEventSchema().optional(),
+        additionalConnectableEventSchema().optional(),
+      )
+      .min(1)
+      .required(),
+    functions: Joi.object({
+      mount: Joi.function(),
+      unmount: Joi.function(),
+      execute: Joi.function().required(),
+      handle: Joi.function().required(),
+      fire: Joi.function(),
+    }).required(),
+  })
+    .concat(commonSchema())
+    .concat(commonEventsSchema());
+
+export const actionSchema = () =>
+  Joi.alternatives(syncActionSchema(), asyncActionSchema());
+
 export const eventSchema = () =>
   Joi.alternatives(triggerSchema(), actionSchema());
 
@@ -256,12 +340,25 @@ export const triggerOutputSchema = () =>
   });
 
 export const actionOutputSchema = () =>
-  Joi.object({
-    output: Joi.alternatives(
-      Joi.array(),
-      Joi.object(),
-    ).required(),
-    flags: Joi.object()
-      .pattern(Joi.string(), Joi.valid(true))
-      .required(),
-  });
+  Joi.alternatives(
+    // standard output
+    Joi.object({
+      output: Joi.alternatives(
+        Joi.array(),
+        Joi.object(),
+      ).required(),
+      flags: Joi.object()
+        .pattern(Joi.string(), Joi.valid(true))
+        .required(),
+    }),
+    // memory output
+    Joi.object({
+      memory: Joi.object().required(),
+      output: Joi.alternatives(
+        Joi.array(),
+        Joi.object(),
+      ),
+      flags: Joi.object()
+        .pattern(Joi.string(), Joi.valid(true)),
+    }).and(`output`, `flags`),
+  );

package/src/entities/source.ts

@@ -4,11 +4,13 @@ import { Common, commonSchema } from "./commons";
 
 export type Source = Common & {
   model: "source",
+  sandbox: boolean,
   fields: Field[],
 };
 
 export const sourceSchema = () =>
   Joi.object({
     model: Joi.valid(`source`).required(),
+    sandbox: Joi.boolean().required(),
     fields: fieldsSchema().required().min(1),
   }).concat(commonSchema());

package/src/index.ts

@@ -1,10 +1,10 @@
 export { Core, core } from './core';
 export { CoreFunction, idSchema } from './entities/commons';
 export { Credentials, credentialsSchema, OAuthCredentials, oauthCredentialsSchema, SessionCredentials, sessionCredentialsSchema, StaticCredentials, staticCredentialsSchema } from './entities/credentials';
-export { Action, actionOutputSchema, actionSchema, Event, eventSchema, ImmediateTrigger, immediateTriggerSchema, Request, ScheduledTrigger, scheduledTriggerSchema, Trigger, triggerOutputSchema, triggerSchema } from './entities/events';
+export { Action, actionOutputSchema, actionSchema, AsyncAction, Event, eventSchema, ImmediateTrigger, immediateTriggerSchema, Request, ScheduledTrigger, scheduledTriggerSchema, syncActionSchema, Trigger, triggerOutputSchema, triggerSchema } from './entities/events';
 export { Provider, providerSchema } from './entities/provider';
 export { Source } from './entities/source';
-export { extract, Field, fieldSchema, fieldsSchema, File, SelectFieldChoice, validate, ValidationResult } from './minified-utils/fields';
+export { alter, extract, Field, fieldSchema, fieldsSchema, File, SelectFieldChoice, validate, ValidationResult } from './minified-utils/fields';
 export { i18n, LocalizedField, LocalizedProperties, localizeFields, localizeGroup, localizeInputs, localizeOutputs, localizeProperties } from './minified-utils/locales';
 export { Properties } from './minified-utils/properties';
 export { Protocol } from './minified-utils/protocol';