@vertesia/common 0.42.2

package/src/runs.ts

@@ -0,0 +1,27 @@
+import { FacetResult } from './facets.js';
+import { NamedInteractionExecutionPayload } from './interaction.js';
+
+/**
+ * Interaction execution payload for creating a new run
+ * It uses interaction field (from NamedInteractionExecutionPayload) to pass the intercation ID to run
+ */
+export interface RunCreatePayload extends NamedInteractionExecutionPayload {
+}
+
+/**
+ * To be used as a value for a numeric or date filters
+ */
+export interface RangeValue {
+    gt?: number | string,
+    gte?: number | string,
+    lt?: number | string,
+    lte?: number | string,
+}
+
+export interface RunSearchMetaRepsonse {
+    count: {
+        lower_bound?: number,
+        total?: number,
+    },
+    facet: Record<string, FacetResult>
+}

package/src/store/activity-catalog.ts

@@ -0,0 +1,39 @@
+export type TsPropType = "string" | "number" | "boolean" | "record" | "object" | "array" | "enum" | "literal" | "union" | "promise" | "any";
+
+// generic types are replaced by "any"
+export interface ActivityTypeDefinition {
+    name: TsPropType;
+    // in case of primitives will be the type name: string, boolean number.
+    // in case of objects or enums will be the object name
+    // in case of arrays will be String(itemType.value)+"[]"
+    // in case of primitive literals will be the value
+    // or nested objects / arrays will be "object" or "array"
+    // for record this is Record<type,type>
+    value: string | boolean | number;
+    // in case of objects
+    members?: ActivityPropertyDefinition[];
+    // in case of arrays or promises will be innertype (i.e. the element type for arrays)
+    innerType?: ActivityTypeDefinition;
+    // in case of enums the enum values will be here
+    enum?: string[] | number[] | undefined;
+    // in case of unions
+    union?: ActivityTypeDefinition[];
+}
+
+export interface ActivityPropertyDefinition {
+    name: string;
+    type: ActivityTypeDefinition;
+    optional: boolean;
+}
+
+export interface ActivityDefinition {
+    name: string;
+    description?: string;
+    paramsType: string;
+    params: ActivityPropertyDefinition[];
+    returnType?: ActivityTypeDefinition | undefined;
+}
+
+export interface ActivityCatalog {
+    activities: ActivityDefinition[];
+}

package/src/store/common.ts

@@ -0,0 +1,10 @@
+export interface BaseObject {
+    id: string;
+    name: string;
+    description?: string;
+    tags?: string[];
+    updated_by: string;
+    created_by: string;
+    created_at: string;
+    updated_at: string;
+}

package/src/store/dsl-workflow.ts

@@ -0,0 +1,289 @@
+import { StringValue } from "ms";
+import { BaseObject } from "./common.js";
+import { WorkflowExecutionPayload } from "./index.js";
+import { ParentClosePolicyType } from "./temporalio.js";
+
+/**
+ * The interface of a function that can be used as a DSL workflow activity.
+ */
+export interface DSLActivityFn {
+    (payload: DSLActivityExecutionPayload): Promise<any>;
+}
+
+
+/**
+ * The payload sent when starting a workflow from the temporal client to the workflow instance.
+ */
+export interface DSLWorkflowExecutionPayload extends WorkflowExecutionPayload {
+    /**
+     * The workflow definition to be used by the DSL workflow.
+     * If a dsl workflow is executed and no definition is provided the workflow will fail.
+     */
+    workflow: DSLWorkflowSpec;
+}
+
+/**
+ * The payload for a DSL acitivty options.
+ *
+ * @see ActivityOptions in @temporalio/common
+ */
+export interface DSLActivityOptions {
+    startToCloseTimeout?: StringValue | number;
+    scheduleToStartTimeout?: StringValue | number;
+    scheduleToCloseTimeout?: StringValue | number;
+    retry?: DSLRetryPolicy;
+}
+
+/**
+ * The payload for a DSL retry policy.
+ *
+ * @see RetryPolicy in @temporalio/common
+ */
+export interface DSLRetryPolicy {
+    backoffCoefficient?: number;
+    initialInterval?: StringValue | number;
+    maximumAttempts?: number;
+    maximumInterval?: StringValue | number;
+    nonRetryableErrorTypes?: string[];
+}
+
+/**
+ * The payload for a DSL activity execution.
+ */
+export interface DSLActivityExecutionPayload extends WorkflowExecutionPayload {
+    activity: DSLActivitySpec;
+    params: Record<string, any>;
+    workflow_name: string;
+    debug_mode?: boolean;
+}
+
+
+export type ImportSpec = (string | Record<string, string>)[];
+export interface ActivityFetchSpec {
+    /**
+     * The data provider name
+     */
+    type: "document" | "document_type" | "interaction_run";
+    /**
+     * An optinal URI to the data source.
+     */
+    source?: string;
+    /**
+     * The query to be executed by the data provider
+     */
+    query: Record<string, any>;
+    /**
+     * a string of space separated field names.
+     * Prefix a field name with "-" to exclude it from the result.
+     */
+    select?: string;
+
+    /**
+     * The number of results to return. If the result is limitedto 1 the result will be a single object
+     */
+    limit?: number;
+
+    /**
+     * How to handle not found objects.
+     * 1. ignore - Ignore and return an empty array for multi objects query (or undefined for single object query) or empty array for multiple objectthrow an error.
+     * 2. throw - Throw an error if the object or no objects are found.
+     */
+    on_not_found?: "ignore" | "throw";
+}
+
+export interface DSLWorkflowStepBase {
+    /**
+     * The type fo the step.
+     * If not set defaults to "activity"
+     */
+    type: "activity" | "workflow";
+}
+
+export interface DSLActivitySpec<PARAMS extends Record<string, any> = Record<string, any>> {
+    /**
+     * The name of the activity function
+     */
+    name: string;
+    /**
+     * Title of the activity to be displayed in the UI workflow builder
+     */
+    title?: string;
+    /**
+     * The description of the activity to e displayed in the UI workflow builder
+     */
+    description?: string;
+    /**
+     * Activities parameters. These parameters can be either literals
+     * (hardcoded strings, numbers, booleans, obejcts, arrays etc.), either
+     * references to the workflow variables.
+     * The workflow variables are built from the workflow params (e.g. the workflow configuration)
+     * and from the result of the previous activities.
+     */
+    params?: PARAMS;
+    /**
+     * The name of the workflow variable that will store the result of the activity
+     * If not specified the result will not be stored
+     * The parameters describe how the actual parameters will be obtained from the worlkfow execution vars.
+     * since it may contain references to workflow execution vars.
+     */
+    output?: string;
+
+    /**
+     * A JSON expression which evaluate to true or false similar to mongo matches.
+     * We support fow now basic expreion like: $true, $false, $eq, $ne, $gt, $gte, $lt, $lte, $in, $nin, $regexp
+     * {$eq: {name: value}},
+     * Ex: {$eq: {wfVarName: value}}
+     */
+    condition?: Record<string, any>;
+
+    /**
+     * The import spec is used to import data from workflow variables.
+     * The import spec is a list of variable names to import from the workflow context.
+     * You can also use objects to rename the imported variables, or to reference an expression.
+     * Example:
+     * ["runId", {"typeId": "docType.id"}]
+     */
+    import?: ImportSpec;
+
+    /**
+     * The fetch phase is used to fetch data from external sources.
+     */
+    fetch?: Record<string, ActivityFetchSpec>;
+
+    /**
+     * Projection to apply to the result. Not all activities support this.
+     */
+    projection?: never | Record<string, any>;
+
+    // ---------- Optional features not implemented in a first step ------------
+    /**
+     * If true the activity will be executed in parallel with the other activities.
+     * (i.e. the workflow will not wait for the activity to finish before starting the next one)
+     */
+    parallel?: boolean;
+
+    /**
+     * Await for a parallel activity execution to return.
+     */
+    await?: string; //the activity name to await
+
+    /**
+     * Activity options for configuring the activity execution, which overrides the activity options
+     * defined at workflow level.
+     */
+    options?: DSLActivityOptions;
+}
+
+export interface DSLActivityStep<PARAMS extends Record<string, any> = Record<string, any>> extends DSLActivitySpec<PARAMS>, DSLWorkflowStepBase {
+    type: "activity";
+}
+
+export interface DSLChildWorkflowStep extends DSLWorkflowStepBase {
+    type: "workflow";
+    // the workflow endpoint to run
+    name: string;
+    /**
+     * The parameters to pass to the child workflow.
+     * These parameters will be merged over the parent workflow vars and passed altogether to the child workflow.
+     */
+    vars?: Record<string, any>;
+    // whether or not to wait for the workflow to finish.
+    // default is false. (the parent workflow will await for the workflow to finish)
+    async?: boolean;
+    /**
+     * The name of the workflow variable that will store the result of the child workflow (if async the workflow id is stored)
+     * If not specified the result will not be stored
+     * The parameters describe how the actual parameters will be obtained from the worlkfow execution vars.
+     * since it may contain references to workflow execution vars.
+     */
+    output?: string;
+    /**
+     * In case the dslWorkflow is used as a child workflow the spec is used to define the child workflow.
+     * If spec is defined then the name must be "dslWorkflow"
+     */
+    spec?: DSLWorkflowSpec;
+    options?: {
+        memo?: Record<string, any>;
+        retry?: DSLRetryPolicy;
+        searchAttributes?: Record<string, string[] | number[] | boolean[] | Date[]>;
+        taskQueue?: string;
+        workflowExecutionTimeout?: StringValue | number;
+        workflowRunTimeout?: StringValue | number;
+        workflowTaskTimeout?: StringValue | number;
+        workflowId?: string;
+        cronSchedule?: string;
+        parentClosePolicy?: ParentClosePolicyType;
+        //TODO
+        //cancellationType
+        //versioningIntent
+        //workflowIdReusePolicy
+    }
+}
+
+export type DSLWorkflowStep = DSLActivityStep | DSLChildWorkflowStep;
+
+export interface DSLWorkflowSpecBase {
+    name: string;
+    description?: string;
+    tags?: string[];
+
+    steps?: DSLWorkflowStep[] | never;
+    /**
+     * @deprecated use steps instead
+     */
+    activities?: DSLActivitySpec[] | never;
+
+    // a dictionary of vars to initialize the workflow execution vars
+    // Initial vars cannot contains references to other vars
+    vars: Record<string, any>;
+    // activity options that apply to all activities within the workflow
+    options?: DSLActivityOptions;
+    // the name of the variable that will hold the workflow result
+    // if not specified "result" will be assumed
+    result?: string;
+    debug_mode?: boolean;
+}
+
+export interface DSLWorkflowSpecWithSteps extends DSLWorkflowSpecBase {
+    steps: DSLWorkflowStep[];
+    /**
+     * @deprecated use steps instead
+     */
+    activities?: never;
+}
+
+/**
+ * @deprecated use steps instead
+ */
+export interface DSLWorkflowSpecWithActivities extends DSLWorkflowSpecBase {
+    steps?: never;
+    /**
+     * @deprecated use steps instead
+     */
+    activities: DSLActivitySpec[];
+}
+
+/**
+ * activities and steps fields are mutally exclusive
+ * steps was added after activities and may contain a mix of activities and other tasks like exec child workflows.
+ * For backward compatibility we keep the activities field as a fallback but one should use one or the other not both.
+ */
+export type DSLWorkflowSpec = DSLWorkflowSpecWithSteps | DSLWorkflowSpecWithActivities;
+
+export interface DSLWorkflowDefinition extends BaseObject, DSLWorkflowSpecBase {
+    // an optional JSON schema to describe the input vars of the workflow.
+    input_schema?: Record<string, any>;
+    activities?: DSLActivitySpec[];
+    steps?: DSLWorkflowStep[];
+}
+
+export interface WorkflowDefinitionRef {
+    id: string;
+    name: string;
+    description?: string;
+    tags?: string[];
+    created_at: Date;
+    updated_at: Date;
+}
+
+export const WorkflowDefinitionRefPopulate = "id name description tags created_at updated_at"

package/src/store/index.ts

@@ -0,0 +1,7 @@
+export * from "./activity-catalog.js";
+export * from "./common.js";
+export * from "./dsl-workflow.js";
+export * from "./object-types.js";
+export * from "./store.js";
+export * from "./temporalio.js";
+export * from "./workflow.js";

package/src/store/ms.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Types for the `ms` package (version 3.0.0-canary.1)
+ */
+declare module "ms" {
+    declare type Unit = 'Years' | 'Year' | 'Yrs' | 'Yr' | 'Y' | 'Weeks' | 'Week' | 'W' | 'Days' | 'Day' | 'D' | 'Hours' | 'Hour' | 'Hrs' | 'Hr' | 'H' | 'Minutes' | 'Minute' | 'Mins' | 'Min' | 'M' | 'Seconds' | 'Second' | 'Secs' | 'Sec' | 's' | 'Milliseconds' | 'Millisecond' | 'Msecs' | 'Msec' | 'Ms';
+    declare type UnitAnyCase = Unit | Uppercase<Unit> | Lowercase<Unit>;
+    export declare type StringValue = `${number}` | `${number}${UnitAnyCase}` | `${number} ${UnitAnyCase}`;
+    declare function ms(value: StringValue, options?: Options): number;
+    declare function ms(value: number, options?: Options): string;
+    export default ms;
+}

package/src/store/object-types.ts

@@ -0,0 +1,128 @@
+import { JSONSchemaType } from "ajv"
+
+/*Default JSON Schema type for rendition*/
+
+export interface RenditionProperties {
+    mime_type: string,
+    source_etag?: string,
+    height?: number,
+    width?: number,
+    multipart?: boolean,
+    total_parts?: number,
+}
+
+export const RenditionSchema: JSONSchemaType<RenditionProperties> = {
+    
+    type: "object",
+    description: "Represent a rendition of a file stored in an object. It will be stored as a separate object in the database.",
+    properties: {
+        mime_type: {
+            type: "string",
+            description: "The format of the rendition. This is a MIME type."
+        },
+        source_etag: {
+            type: "string",
+            description: "The ETag of the file used for the rendition.",
+            nullable: true
+        },
+        height: {
+            type: "integer",
+            description: "The height of the rendition",
+            nullable: true
+        },
+        width: {
+            type: "integer",
+            description: "The width of the rendition",
+            nullable: true
+        },
+        multipart: {
+            type: "boolean",
+            description: "If the rendition is a multi-part rendition",
+            nullable: true,
+            default: false
+        },
+        total_parts: {
+            type: "integer",
+            description: "The total number of parts in the rendition",
+            nullable: true
+        }
+    },
+    required: ["mime_type"],
+}
+
+
+
+export interface DocumentPartProperties {
+
+    source_etag?: string,
+    part_number: number,
+    title?: string,
+    source_line_start?: number,
+    source_line_end?: number,
+    type?: 'text' | 'image' | 'table' | 'chart' | 'diagram' | 'code' | 'other',
+    page_number?: number,
+    description?: string,
+    height?: number,
+    width?: number,
+    
+}
+
+
+export const DocumentPartSchema: JSONSchemaType<DocumentPartProperties> = {
+    type: "object",
+    description: "Represent a semantic chunk of a document",
+    properties: {
+        source_etag: {
+            type: "string",
+            description: "The ETag of the file used for the rendition.",
+            nullable: true
+        },
+        part_number: {
+            type: "integer",
+            description: "The part number of the chunk",
+        },
+        title: {
+            type: "string",
+            description: "The title of the chunk",
+            nullable: true
+        },
+        source_line_start: {
+            type: "integer",
+            description: "The line number where the chunk starts",
+            nullable: true
+        },
+        source_line_end: {
+            type: "integer",
+            description: "The line number where the chunk ends",
+            nullable: true
+        },
+        type: {
+            type: "string",
+            description: "The type of the chunk",
+            enum: ['text', 'image', 'table', 'chart', 'diagram', 'code', 'other'],
+            nullable: true
+        },
+        page_number: {
+            type: "integer",
+            description: "The page number of the document part",
+            nullable: true
+        },
+        description: {
+            type: "string",
+            description: "The description of the document part, if it's an image, the exhaustive description of the image",
+            nullable: true
+        },
+        height: {
+            type: "integer",
+            description: "The height of the rendition",
+            nullable: true
+        },
+        width: {
+            type: "integer",
+            description: "The width of the rendition",
+            nullable: true
+        }
+    },
+    required: ["part_number"],
+}
+