@clxmedia/cliq-project 1.0.11

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 John Biundo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+<h1 align="center"></h1>
+
+<h3 align="center">CLiQ Project</h3>

package/dist/constants.d.ts

@@ -0,0 +1,4 @@
+import type { CLiQTaskNotificationType } from "./types/project.types";
+export declare const constants: {
+    readonly CLiQTaskNotificationTypeFriendly: Record<CLiQTaskNotificationType, string>;
+};

package/dist/constants.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constants = void 0;
+exports.constants = {
+    CLiQTaskNotificationTypeFriendly: {
+        default: "Default",
+        initial_notify: "Initial Notify",
+        first_reminder: "First Reminder",
+        second_reminder: "Second Reminder",
+        third_reminder: "Third Reminder",
+        final_reminder: "Final Reminder",
+        alert: "Alert",
+    },
+};

package/dist/flow-engine.d.ts

@@ -0,0 +1,15 @@
+import type { CLiQProjectFlow, CLiQProjectFlowTemplate, CLiQTaskItemStat } from "./types/project.types";
+export declare class FlowEngine {
+    private flows;
+    private tasks;
+    constructor(flows: CLiQProjectFlow[], tasks: CLiQTaskItemStat[]);
+    static extractAllTaskSlugs(flows: CLiQProjectFlowTemplate[]): string[];
+    getFlows(): CLiQProjectFlow[];
+    getFlowByGuid(guid: string): CLiQProjectFlow | undefined;
+    getActivatedFlows(): CLiQProjectFlow[];
+    isTaskChainCompleted: (task: CLiQTaskItemStat) => boolean;
+    isTaskReady: (task: CLiQTaskItemStat) => boolean;
+    getTasksReadyToInitialize(): number[];
+    getActiveFlowMemberTasks(): number[];
+    getUnlockableTasks(): number[];
+}

package/dist/flow-engine.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowEngine = void 0;
+class FlowEngine {
+    constructor(flows, tasks) {
+        this.flows = [];
+        this.tasks = [];
+        this.isTaskChainCompleted = (task) => {
+            for (const flow of this.getActivatedFlows()) {
+                for (const dep of flow.dependencies) {
+                    if (dep.dependent_task_id === task.id) {
+                        const prereqTask = this.tasks.find((task) => task.id === dep.prerequisite_task_id);
+                        const requiresCompletion = dep.requires_prerequisite_completion;
+                        if (requiresCompletion &&
+                            (!prereqTask || prereqTask.status !== "closed")) {
+                            return false;
+                        }
+                        if ((prereqTask === null || prereqTask === void 0 ? void 0 : prereqTask.status) === "provisional") {
+                            return false;
+                        }
+                        if (prereqTask && !this.isTaskChainCompleted(prereqTask))
+                            return false;
+                    }
+                }
+            }
+            return true;
+        };
+        this.isTaskReady = (task) => {
+            if ((task === null || task === void 0 ? void 0 : task.status) !== "pending")
+                return false;
+            return this.isTaskChainCompleted(task);
+        };
+        this.flows = flows;
+        this.tasks = tasks;
+    }
+    static extractAllTaskSlugs(flows) {
+        if (!flows || flows.length === 0)
+            return [];
+        const taskSlugs = new Set();
+        for (const flow of flows) {
+            for (const dep of flow.dependencies) {
+                taskSlugs.add(dep.dependent_task.task_template_slug);
+                taskSlugs.add(dep.prerequisite_task.task_template_slug);
+            }
+        }
+        return Array.from(taskSlugs);
+    }
+    getFlows() {
+        return this.flows;
+    }
+    getFlowByGuid(guid) {
+        return this.flows.find((flow) => flow.guid === guid);
+    }
+    getActivatedFlows() {
+        return this.flows.filter((flow) => {
+            if (!flow.activated_by_task_id)
+                return true;
+            const task = this.tasks.find((task) => task.id === flow.activated_by_task_id);
+            if (!task)
+                return true;
+            return task.status === "closed";
+        });
+    }
+    getTasksReadyToInitialize() {
+        const taskIds = new Set();
+        for (const flow of this.flows) {
+            for (const dep of flow.dependencies) {
+                const tasks = this.tasks.filter((task) => [dep.dependent_task_id, dep.prerequisite_task_id].includes(task.id) && task.status === "provisional");
+                for (const t of tasks) {
+                    taskIds.add(t.id);
+                }
+            }
+        }
+        return Array.from(taskIds);
+    }
+    getActiveFlowMemberTasks() {
+        const taskIds = new Set();
+        for (const flow of this.flows.filter((f) => f.initialized_at)) {
+            for (const dep of flow.dependencies) {
+                const tasks = this.tasks.filter((task) => [dep.dependent_task_id, dep.prerequisite_task_id].includes(task.id));
+                for (const t of tasks) {
+                    taskIds.add(t.id);
+                }
+            }
+        }
+        return Array.from(taskIds);
+    }
+    getUnlockableTasks() {
+        const unlockableTasks = new Set();
+        const activatedFlows = this.getActivatedFlows();
+        const tasks = this.tasks;
+        for (const flow of activatedFlows) {
+            for (const dep of flow.dependencies) {
+                const task = tasks.find((task) => task.id === dep.dependent_task_id);
+                if (task && this.isTaskReady(task)) {
+                    unlockableTasks.add(dep.dependent_task_id);
+                }
+            }
+            const allDependentIds = new Set(flow.dependencies.map((d) => d.dependent_task_id));
+            const startingPrereqIds = flow.dependencies
+                .filter((d) => !allDependentIds.has(d.prerequisite_task_id))
+                .map((d) => d.prerequisite_task_id);
+            for (const prereqId of startingPrereqIds) {
+                const prereqTask = tasks.find((task) => task.id === prereqId);
+                if (prereqTask && this.isTaskReady(prereqTask)) {
+                    unlockableTasks.add(prereqId);
+                }
+            }
+        }
+        return Array.from(unlockableTasks);
+    }
+}
+exports.FlowEngine = FlowEngine;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { FlowEngine } from "./flow-engine";
+export { constants } from "./constants";
+export type * from "./types/project.types";

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constants = exports.FlowEngine = void 0;
+var flow_engine_1 = require("./flow-engine");
+Object.defineProperty(exports, "FlowEngine", { enumerable: true, get: function () { return flow_engine_1.FlowEngine; } });
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "constants", { enumerable: true, get: function () { return constants_1.constants; } });

package/dist/types/project.types.d.ts

@@ -0,0 +1,427 @@
+import type { CLiQUserLocator, CLiQUserLocatorSlug } from "@clxmedia/types/core/auth";
+import type { CLXFormRuleSet } from "@clxmedia/types/core/clxforms";
+import type { EnterpriseEventSlugs } from "@clxmedia/types/core/events";
+export type CLiQTaskTemplate = {
+    slug: string;
+    name: string;
+    default_assignment: CLiQUserLocator | null;
+    description: string | null;
+    instructions: string | null;
+    _count: {
+        checklist_items: number;
+        project_task_templates: number;
+    };
+    checklist_items: CLiQTaskChecklistItemTemplate[];
+    project_task_templates: {
+        project_step_template: {
+            project_template_slug: string;
+        };
+    }[];
+};
+export type CLiQSortDirection = "asc" | "desc";
+export type ISODateString = `${number}-${number}-${number}`;
+export type CLiQProjectActionType = "create" | "activate" | "notify" | "complete" | "archive";
+export type CLiQRuleConditionAction = "initialize" | "delete" | "require" | "unrequire";
+export type CLiQTaskTargetType = "none" | "snapshot" | "access_request" | "form_collab";
+export type CLiQTaskActionType = "complete" | "create" | "activate" | "notify" | "assign" | "comment" | "start" | "skip" | "reject" | "verify" | "close";
+export type CLiQTaskHistoryArchive = {
+    id: number;
+    action_type: CLiQTaskActionType;
+    action_by_user: string;
+    description?: string;
+    action_slug?: string;
+    created_at: Date;
+};
+export type CLiQTaskArchive = {
+    id: number;
+    slug: string;
+    master_id: number;
+    name: string;
+    created_at: Date;
+    is_required: boolean;
+    activated_at: Date;
+    closed_at: Date;
+    resolution: string;
+    history: CLiQTaskHistoryArchive[];
+};
+export type CLiQTaskFilter = {
+    cliq_user_locator_slug?: CLiQUserLocatorSlug;
+    my_tasks?: boolean;
+    master_id?: number;
+    include_closed?: boolean;
+    slug?: string;
+    take?: number;
+    skip?: number;
+    sort_by?: string;
+    sort_direction?: CLiQSortDirection;
+};
+export type PagedResult<T> = {
+    items: T[];
+    total: number;
+    take: number;
+    skip: number;
+};
+export type CLiQUserInstance = {
+    id: number;
+    email: string;
+    name: string;
+};
+export type CLiQProjectDetails = {
+    implementation_specialist?: CLiQUserInstance;
+    client_service_analyst?: CLiQUserInstance;
+};
+export type CLiQTaskFlowDependency = {
+    guid: string;
+    prerequisite_task_id: number;
+    dependent_task_id: number;
+    requires_prerequisite_completion: boolean;
+    flow_guid: string;
+};
+export type CLiQProjectFlow = {
+    name: string;
+    guid: string;
+    initialized_at: Date | null;
+    project_id: number;
+    rule_triggers: CLiQRuleTrigger[];
+    activated_by_task_id: number | null;
+    restart_task_id: number | null;
+    restart_label?: string;
+    dependencies: CLiQTaskFlowDependency[];
+};
+export type CLiQProjectInstance = {
+    id: number;
+    master_id: number;
+    name: string;
+    slug: string;
+    details?: CLiQProjectDetails;
+    created_at: Date;
+    updated_at: Date;
+    archived_at: Date | null;
+    steps: CLiQProjectStepInstance[];
+    flows?: CLiQProjectFlow[];
+};
+export type CLiQProjectMetaData = {
+    reminders?: ProjectReminderScheduleConfig;
+    notifications?: ProjectNotificationConfig[];
+};
+export type CLiQProjectStepInstance = {
+    id: number;
+    project_id: number;
+    name: string;
+    status: CLiQTaskStatus;
+    project_tasks: CLiQTask[];
+};
+export type CLiQTaskChecklistItemTemplate = {
+    id: number | null;
+    task_slug: string;
+    description: string;
+    required: boolean;
+    order_num: number | null;
+};
+export type CLiQTaskChecklistItem = {
+    id: number;
+    task_slug: string;
+    description: string;
+    required: boolean;
+    order_num: number;
+    created_at: Date;
+};
+export type TimeDelay = {
+    unit: "seconds" | "minutes" | "hours" | "days" | "business_days";
+    value: number;
+} | "immediately";
+export type ProjectReminderScheduleEntry = {
+    reminder_type: string;
+    delay: TimeDelay;
+    recipients: ProjectReminderRecipients;
+};
+export type Origin = {
+    type: "task" | "project_step" | "project";
+    id: number;
+    name: string;
+    entity: {
+        master_id: number;
+        name: string;
+    };
+    resource?: {
+        label: string;
+        path: string;
+    };
+};
+export type TaskNotificationRecipientLocator = CLiQUserLocator | {
+    type: "current_assignee";
+};
+export type TaskNotificationRecipients = {
+    to: TaskNotificationRecipientLocator | TaskNotificationRecipientLocator[];
+    cc?: TaskNotificationRecipientLocator | TaskNotificationRecipientLocator[];
+    bcc?: TaskNotificationRecipientLocator | TaskNotificationRecipientLocator[];
+};
+export type ProjectNotificationRecipients = {
+    to: CLiQUserLocator | CLiQUserLocator[];
+    cc?: CLiQUserLocator | CLiQUserLocator[];
+    bcc?: CLiQUserLocator | CLiQUserLocator[];
+};
+export type TaskNotificationConfig = {
+    onAction: CLiQTaskActionType;
+    templateSlug: string;
+    recipients: TaskNotificationRecipients;
+    repeatable: boolean;
+};
+export type ProjectNotificationConfig = {
+    onAction: CLiQProjectActionType;
+    templateSlug: string;
+    recipients: ProjectNotificationRecipients;
+    repeatable: boolean;
+};
+export type ProjectNotificationConfigs = {
+    configs: ProjectNotificationConfig[];
+};
+export type ProjectReminderRecipients = {
+    to: CLiQUserLocator | CLiQUserLocator[];
+    cc?: CLiQUserLocator | CLiQUserLocator[];
+    bcc?: CLiQUserLocator | CLiQUserLocator[];
+};
+export type TaskReminderRecipients = {
+    to: TaskNotificationRecipientLocator | TaskNotificationRecipientLocator[];
+    cc?: TaskNotificationRecipientLocator | TaskNotificationRecipientLocator[];
+    bcc?: TaskNotificationRecipientLocator | TaskNotificationRecipientLocator[];
+};
+export type ReminderRecipients = TaskReminderRecipients | ProjectReminderRecipients;
+type OriginLocatorBase = {
+    type?: string;
+    origin_time: number;
+    id: number;
+};
+export type TaskOriginLocator = OriginLocatorBase & {
+    type: "task";
+};
+export type ProjectOriginLocator = OriginLocatorBase & {
+    type: "project_step" | "project";
+};
+export type OriginLocator = TaskOriginLocator | ProjectOriginLocator;
+export type TaskReminderScheduleEntry = {
+    reminder_type: CLiQTaskNotificationType;
+    delay: TimeDelay;
+    recipients: TaskReminderRecipients;
+};
+export type ReminderScheduleEntry = TaskReminderScheduleEntry | ProjectReminderScheduleEntry;
+export type TaskReminderConfig = {
+    origin_status: CLiQTaskActionType;
+    template_slug: string;
+    schedule: TaskReminderScheduleEntry[];
+};
+export type TaskActivateReminderConfig = TaskReminderConfig & {
+    origin_status: "create";
+    target_status: "activate";
+};
+export type TaskCompleteReminderConfig = TaskReminderConfig & {
+    origin_status: "activate";
+    target_status: "complete";
+};
+export type TaskReminderScheduleConfig = {
+    activate?: TaskActivateReminderConfig;
+    complete?: TaskCompleteReminderConfig;
+};
+export type TaskReminderConfigTypes = TaskActivateReminderConfig | TaskCompleteReminderConfig;
+export type ProjectReminderConfigTypes = ProjectActivateReminderConfig | ProjectCompleteReminderConfig;
+export type ProjectActivateReminderConfig = ProjectReminderConfig & {
+    origin_status: "create";
+    target_status: "activate";
+};
+export type ProjectCompleteReminderConfig = ProjectReminderConfig & {
+    origin_status: "activate";
+    target_status: "complete";
+};
+export type ProjectReminderScheduleConfig = {
+    activate?: ProjectActivateReminderConfig;
+    complete?: ProjectCompleteReminderConfig;
+};
+export type ProjectReminderConfig = {
+    origin_status: CLiQProjectActionType;
+    template_slug: string;
+    schedule: ProjectReminderScheduleEntry[];
+};
+export type CLiQProjectTemplate = {
+    name: string;
+    slug: string;
+    allow_multiple: boolean;
+    notifications?: ProjectNotificationConfig[];
+    reminders?: ProjectReminderScheduleConfig;
+    steps: CLiQProjectStepTemplate[];
+    flows: CLiQProjectFlowTemplate[];
+};
+export type CLiQProjectStepTemplate = {
+    name: string;
+    slug: string;
+    notifications?: ProjectNotificationConfig[];
+    reminders?: ProjectReminderScheduleConfig;
+    tasks: CLiQProjectTaskTemplate[];
+    defaultComplete?: boolean;
+    order_num: number;
+};
+export type CLiQTaskTriggerConstraint = "event_user_to_onboarding_recipient_match" | "project_id_match";
+export type CLiQTaskTriggerConfig = {
+    constraints: CLiQTaskTriggerConstraint[];
+};
+export type CLiQEventTrigger = {
+    id: number;
+    trigger_action: CLiQTaskActionType;
+    trigger_event_slug: EnterpriseEventSlugs;
+    trigger_config: CLiQTaskTriggerConfig;
+};
+export type CLiQRuleTrigger = {
+    id: number;
+    trigger_action: CLiQRuleConditionAction;
+    trigger_ruleset: CLXFormRuleSet;
+};
+export type CLiQProjectTaskTemplateThin = {
+    guid: string;
+    name: string;
+    task_template_slug: string;
+};
+export type CLiQTaskItemStat = {
+    id: number;
+    name: string;
+    slug: string;
+    status: CLiQTaskStatus;
+};
+export type CLiQProjectTaskTemplate = CLiQProjectTaskTemplateThin & {
+    required: boolean;
+    notifications?: TaskNotificationConfig[];
+    reminders?: TaskReminderScheduleConfig;
+    default_assignment?: CLiQUserLocator;
+    order_num: number;
+    event_triggers?: CLiQEventTrigger[];
+    rule_triggers?: CLiQRuleTrigger[];
+    checklist?: CLiQTaskChecklistItemTemplate[];
+};
+export type CLiQProjectFlowTemplate = {
+    name: string;
+    guid: string;
+    project_template_slug: string;
+    activated_by_task_guid?: string;
+    restart_task_guid?: string;
+    restart_label?: string;
+    rule_triggers?: CLiQRuleTrigger[];
+    dependencies: CLiQTaskFlowDependencyTemplate[];
+};
+export type CLiQTaskFlowDependencyTemplate = {
+    guid: string;
+    prerequisite_task: CLiQProjectTaskTemplateThin;
+    dependent_task: CLiQProjectTaskTemplateThin;
+    requires_prerequisite_completion: boolean;
+};
+export type CLiQProjectConfig = {
+    name: string;
+    slug: string;
+    notifications: ProjectNotificationConfig[];
+    reminders: ProjectReminderScheduleConfig;
+    steps: {
+        name: string;
+        slug: string;
+        notifications: ProjectNotificationConfig[];
+        reminders: ProjectReminderScheduleConfig;
+        order_num: number;
+        tasks: {
+            guid: string;
+            provisional: boolean;
+            name: string;
+            task_template_slug: string;
+            required: boolean;
+            default_assignment: CLiQUserLocator;
+            notifications: TaskNotificationConfig[];
+            reminders: TaskReminderScheduleConfig;
+            rule_triggers: CLiQRuleTrigger[];
+            event_triggers: CLiQEventTrigger[];
+            order_num: number;
+        }[];
+    }[];
+};
+export type CLiQTaskResolution = "done" | "skipped" | "none" | "wont_do";
+export type CLiQTaskBase = {
+    id: number;
+    master_id: number;
+    name: string;
+    slug: string;
+    is_required: boolean;
+    initialized_at: Date | null;
+    created_at: Date;
+    activated_at: Date | null;
+    closed_at: Date | null;
+    resolution: CLiQTaskResolution;
+};
+export type CLiQTaskTag = {
+    id: number;
+    task_id: number;
+    name: string;
+    added_by_user_id?: number;
+    comment?: string;
+    created_at: Date;
+};
+export type CLiQTaskMetaData = {
+    resource?: {
+        path: string;
+        label: string;
+    };
+    reminders?: TaskReminderScheduleConfig;
+    notifications?: TaskNotificationConfig[];
+};
+export type CLiQTaskStatus = "provisional" | "pending" | "open" | "closed";
+export type CLiQTaskTarget = {
+    type: CLiQTaskTargetType;
+    id: number | null;
+};
+export type CLiQTask = CLiQTaskBase & {
+    id: number;
+    is_required: boolean;
+    conditions: CLXFormRuleSet | null;
+    project_step_id?: number;
+    internal_only: boolean;
+    meta_data?: CLiQTaskMetaData;
+    description?: string;
+    instructions?: string;
+    due_at: Date | null;
+    updated_at?: Date;
+    entity_name: string;
+    assignment: CLiQUserLocator | null;
+    priority: number;
+    responsibility: "internal" | "external";
+    status: CLiQTaskStatus;
+    target: CLiQTaskTarget;
+    tags: CLiQTaskTag[];
+};
+export type CLiQTaskHistoryEntry = {
+    id: number;
+    description: string;
+    created_at: Date;
+    deleted_at: Date | null;
+    action_type: CLiQTaskActionType;
+    action_slug: string | null;
+    action_by_user: {
+        id: number;
+        email: string;
+    };
+};
+export type TaskChecklistItem = {
+    id: number;
+    task_id: number;
+    description: string;
+    required: boolean;
+    completed_by: number | null;
+    order_num: number;
+};
+export type CLiQTaskWithHistory = CLiQTask & {
+    history: CLiQTaskHistoryEntry[];
+    checklist?: TaskChecklistItem[];
+    project_step?: {
+        id: number;
+        name: string;
+        project: {
+            id: number;
+            name: string;
+            slug: string;
+        };
+    };
+};
+export type CLiQTaskNotificationType = "default" | "initial_notify" | "first_reminder" | "second_reminder" | "third_reminder" | "final_reminder" | "alert";
+export {};

package/dist/types/project.types.js

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

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@clxmedia/cliq-project",
+  "version": "1.0.11",
+  "description": "CLiQ Projects",
+  "author": "Brandon Thompson <brandont@clxmedia.com>",
+  "license": "MIT",
+  "readmeFilename": "README.md",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*",
+    "*.md"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
+    "./constants": "./dist/constants.js",
+    "./flow-engine": "./dist/flow-engine.js"
+  },
+  "scripts": {
+    "start:dev": "tsc -w",
+    "build": "rm -Rf dist && tsc",
+    "prepare": "npm run build",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "lint": "tslint -p tsconfig.json -c tslint.json",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:cov": "vitest run --coverage"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/adsupnow/xperience-library/cliq-project"
+  },
+  "bugs": "https://github.com/adsupnow/xperience-library/cliq-project/issues",
+  "dependencies": {
+    "@clxmedia/types": "1.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.3",
+    "@vitest/coverage-v8": "3.2.4",
+    "nock": "13.5.4",
+    "tslint": "6.1.3",
+    "typescript": "^5.2.2",
+    "vitest": "3.2.4"
+  }
+}