@avakado.ai/schemas 1.1.1 → 1.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avakado.ai/schemas",
-  "version": "1.1.1",
+  "version": "1.1.6",
   "description": "Canonical Mongo schemas, models, enums and index declarations shared by the Avakado services.",
   "license": "UNLICENSED",
   "type": "module",

package/src/enums/index.js

@@ -62,3 +62,5 @@ export const CAMPAIGN_STATUS = ["pending", "active", "completed"];
 export const TASK_STATUS = ["pending", "in-progress", "completed", "failed", "skipped"];
 export const TASK_TYPES = ["quick", "webhook"];
 export const TASK_REFERENCE_TYPES = ["Message", "CallSession"];
+
+export const OAUTH_GRANT_MODES = ["access_refresh", "access_only", "permanent"];

package/src/models/Action.js

@@ -1,5 +1,41 @@
 import { Schema } from "mongoose";
 import { defineModel } from "../runtime.js";
+const taskNodeCoreExecutionSchema = new Schema({
+    template: {
+        id: String,
+        data: Schema.Types.Mixed,
+    },
+    compiledInstructions: String,
+});
+const taskNodeCoreSchema = new Schema({
+    type: { type: String, required: true, enum: ['task', 'conditional'] },
+    input: {
+        schema: Schema.Types.Mixed,
+        mapper: Schema.Types.Mixed,
+        preset: Schema.Types.Mixed,
+    },
+    output: {
+        schema: Schema.Types.Mixed,
+        mapper: Schema.Types.Mixed,
+    },
+    coreExecution: taskNodeCoreExecutionSchema,
+    meta: { label: String, apiId: String }
+});
+const taskNodeChildrenSchema = new Schema({
+    id: String,
+    key: String,
+});
+const taskNodesSchema = new Schema({
+    id: String,
+    meta: { label: String },
+    core: taskNodeCoreSchema,
+    children: [taskNodeChildrenSchema],
+});
+export const Task_Tree = new Schema({
+    rootId: String,
+    rootKey: String,
+    nodes: [taskNodesSchema],
+});
 const ActionSchema = new Schema({
     name: String,
     business: { type: Schema.Types.ObjectId, ref: 'Businesses' },
@@ -11,7 +47,7 @@ const ActionSchema = new Schema({
     functionString: String,
     errorFunction: String,
     UI: Schema.Types.Mixed,
-    isPublic: { type: Boolean, default: false },
+    task: Task_Tree
 }, {
     timestamps: true
 });

package/src/models/OAuth.js

@@ -0,0 +1,60 @@
+import { Schema } from "mongoose";
+import { defineModel } from "../runtime.js";
+import { OAUTH_GRANT_MODES } from "../enums/index.js";
+
+const OAuthClientSchema = new Schema({
+    clientId: { type: String, required: true, unique: true, index: true },
+    name: { type: String, required: true },
+    business: { type: Schema.Types.ObjectId, ref: "Businesses", index: true },
+    createdBy: { type: Schema.Types.ObjectId, ref: "Users", unique: true, sparse: true },
+    secretHash: { type: String, default: null },
+    secretVersion: { type: Number, default: 1 },
+    redirectUris: { type: [String], default: [] },
+    allowedOrigins: { type: [String], default: [] },
+    grantMode: { type: String, enum: OAUTH_GRANT_MODES, required: true, default: "access_refresh" },
+    isFirstParty: { type: Boolean, default: false },
+    revokedAt: { type: Date, default: null },
+}, { timestamps: true });
+
+OAuthClientSchema.index({ business: 1, revokedAt: 1 });
+OAuthClientSchema.index({ allowedOrigins: 1, revokedAt: 1 });
+
+const OAuthAuthorizationCodeSchema = new Schema({
+    codeHash: { type: String, required: true, unique: true },
+    clientId: { type: String, required: true, index: true },
+    user: { type: Schema.Types.ObjectId, ref: "Users", required: true },
+    redirectUri: { type: String, required: true },
+    scope: { type: String, default: "" },
+    codeChallenge: { type: String, default: null },
+    codeChallengeMethod: { type: String, enum: ["S256", "plain"], default: null },
+    expiresAt: { type: Date, required: true },
+    consumedAt: { type: Date, default: null },
+}, { timestamps: true });
+
+OAuthAuthorizationCodeSchema.index({ expiresAt: 1 }, { expireAfterSeconds: 0 });
+
+const OAuthRefreshTokenSchema = new Schema({
+    tokenHash: { type: String, required: true, unique: true },
+    clientId: { type: String, required: true, index: true },
+    user: { type: Schema.Types.ObjectId, ref: "Users", required: true, index: true },
+    familyId: { type: String, required: true, index: true },
+    expiresAt: { type: Date, required: true },
+    usedAt: { type: Date, default: null },
+    revokedAt: { type: Date, default: null },
+}, { timestamps: true });
+
+OAuthRefreshTokenSchema.index({ expiresAt: 1 }, { expireAfterSeconds: 0 });
+OAuthRefreshTokenSchema.index({ clientId: 1, revokedAt: 1 });
+OAuthRefreshTokenSchema.index({ user: 1, revokedAt: 1 });
+
+const OAuthRevokedJtiSchema = new Schema({
+    jti: { type: String, required: true, unique: true },
+    expiresAt: { type: Date, required: true },
+}, { timestamps: true });
+
+OAuthRevokedJtiSchema.index({ expiresAt: 1 }, { expireAfterSeconds: 0 });
+
+export const OAuthClient = defineModel("OAuthClient", OAuthClientSchema, "OAuthClients");
+export const OAuthAuthorizationCode = defineModel("OAuthAuthorizationCode", OAuthAuthorizationCodeSchema, "OAuthAuthorizationCodes");
+export const OAuthRefreshToken = defineModel("OAuthRefreshToken", OAuthRefreshTokenSchema, "OAuthRefreshTokens");
+export const OAuthRevokedJti = defineModel("OAuthRevokedJti", OAuthRevokedJtiSchema, "OAuthRevokedJtis");

package/src/models/TriggersTemplate.js

@@ -0,0 +1,13 @@
+import { Schema } from "mongoose";
+import { defineModel } from "../runtime.js";
+
+const TriggerTemplateSchema = new Schema({
+    name: { type: String, required: true, unique: true }, // convers
+    description: String,
+    type: String,
+    payload: Schema.Types.Mixed,
+}, {
+    timestamps: true,
+});
+TriggerTemplateSchema.index({ name: 1 });
+export const TriggerTemplate = defineModel("TriggerTemplate", TriggerTemplateSchema, "TriggerTemplate");

package/src/models/Workflow.js

@@ -1,44 +1,44 @@
 import { Schema } from "mongoose";
 import { defineModel } from "../runtime.js";
-
+import { Task_Tree } from "./Action.js";
 const WorkflowSchema = new Schema({
     name: { type: String, default: "Untitled Workflow" },
-    status: { type: String, enum: ["draft", "active", "disabled"], default: "draft" },
-    nodes: Object,
-    connections: Object,
+    trigger: { type: String, required: true },
     business: { type: Schema.Types.ObjectId, ref: "Businesses" },
+    status: { type: String, enum: ["active", "disabled"], default: "active" },
+    task: Task_Tree,
     createdBy: { type: Schema.Types.ObjectId, ref: "Users" },
 }, {
     timestamps: true,
 });
-WorkflowSchema.index({ createdBy: 1 });
+WorkflowSchema.index({ trigger: 1, business: 1, status: 1 });
 WorkflowSchema.index({ status: 1 });
 WorkflowSchema.methods.updateStatus = function (status) {
     this.status = status;
     return this.save();
 };
-WorkflowSchema.methods.getNextNode = function ({ currentNode = "", outputPortsOfCurentNode = [] } = {}) {
-    const nextNodes = [];
-    if (!currentNode) return [Object.keys(this.nodes).find((ele) => this.nodes[ele].type === "trigger")];
-    const { type } = this.nodes[currentNode];
-    Object.values(this.connections).forEach((ele) => {
-        if (!ele?.from || !ele?.to) {
-            console.log("errored no from or to");
-            return;
-        }
-        const [fromNodeId, , portId] = ele.from.split("/");
-        if (fromNodeId !== currentNode) {
-            return;
-        }
-        const [toNodeId] = ele.to.split("/");
-        if (type === "conditionalNode") {
-            if (outputPortsOfCurentNode.includes(portId)) nextNodes.push(toNodeId);
-            return;
-        }
-        nextNodes.push(toNodeId);
-    });
-    return nextNodes;
-};
+// WorkflowSchema.methods.getNextNode = function ({ currentNode = "", outputPortsOfCurentNode = [] } = {}) {
+//     const nextNodes = [];
+//     if (!currentNode) return [Object.keys(this.nodes).find((ele) => this.nodes[ele].type === "trigger")];
+//     const { type } = this.nodes[currentNode];
+//     Object.values(this.connections).forEach((ele) => {
+//         if (!ele?.from || !ele?.to) {
+//             console.log("errored no from or to");
+//             return;
+//         }
+//         const [fromNodeId, , portId] = ele.from.split("/");
+//         if (fromNodeId !== currentNode) {
+//             return;
+//         }
+//         const [toNodeId] = ele.to.split("/");
+//         if (type === "conditionalNode") {
+//             if (outputPortsOfCurentNode.includes(portId)) nextNodes.push(toNodeId);
+//             return;
+//         }
+//         nextNodes.push(toNodeId);
+//     });
+//     return nextNodes;
+// };
 
 export { WorkflowSchema };
 export const Workflow = defineModel("Workflow", WorkflowSchema, "Workflow");

package/src/models/index.js

@@ -29,3 +29,4 @@ export { Document } from "./Document.js";
 export { Data } from "./Data.js";
 export { Workflow, WorkflowSchema } from "./Workflow.js";
 export { WorkflowLogs } from "./WorkflowLogs.js";
+export { OAuthClient, OAuthAuthorizationCode, OAuthRefreshToken, OAuthRevokedJti } from "./OAuth.js";

package/src/models/InbuiltNodes.js

@@ -1,19 +0,0 @@
-import { Schema } from "mongoose";
-import { defineModel } from "../runtime.js";
-const NodeSchema = new Schema(
-    {
-        type: { type: String, required: true, enum: ['trigger', 'task', 'conditional'] },
-        core: {
-            inputMapper: String,
-            inputSchema: Schema.Types.Mixed,
-            outputSchema: Schema.Types.Mixed,
-            configSchema: Schema.Types.Mixed,
-            handlerFunction: { type: String, required: true },
-            errorFunction: { type: String }
-        },
-        meta: { label: String }
-    },
-    { timestamps: true }
-);
-export const NodeModel = defineModel('Node', NodeSchema, 'Nodes');
-export const Node = NodeModel;

package/src/models/Triggers.js

@@ -1,17 +0,0 @@
-import { Schema } from "mongoose";
-import { defineModel } from "../runtime.js";
-
-const TriggerSchema = new Schema({
-    business: { type: Schema.Types.ObjectId, ref: 'Businesses' },
-    name: String, // conversationStatusUpdated, leadStatusUpdated, 
-    description: String,
-    type: String, // [open, pending, snoozed, completed, closed, archived, spam] || [new, contacted, qualified, converted, lost]
-    workflows: [{ type: Schema.Types.ObjectId, ref: "Workflow" }],
-}, {
-    timestamps: true,
-});
-
-export { TriggerSchema };
-// No explicit collection name, matching the services: mongoose pluralises this to `triggers`.
-export const Trigger = defineModel('Trigger', TriggerSchema);
-export default Trigger;