@avakado.ai/schemas 1.0.0 → 1.1.0

package/src/models/apiAuthenticator.js

@@ -0,0 +1,197 @@
+import { Schema } from "mongoose";
+import { defineModel, requireDep } from "../runtime.js";
+
+const TOKEN_EXPIRY_BUFFER_MS = 60_000;
+const baseOpts = { _id: false };
+const docOpts = { timestamps: true, discriminatorKey: "authType" };
+const credentialOpts = { _id: false, strict: false };
+
+const ApiAuthenticationSchema = new Schema({
+    provider: { type: Schema.Types.ObjectId, ref: "Providers" },
+    accountDetails: Schema.Types.Mixed,
+    scope: [String],
+    isActive: { type: Boolean, default: true },
+    createdBy: { type: Schema.Types.ObjectId, ref: "Users" },
+    business: { type: Schema.Types.ObjectId, ref: "Businesses" },
+    // Present on host copies that do not use authType discriminators (AvaPhone / socketio).
+    credentials: Schema.Types.Mixed,
+    config: Schema.Types.Mixed,
+}, docOpts);
+
+const oauth2CredentialsSchema = new Schema({
+    tokenId: String,
+    accessToken: String,
+    refreshToken: String,
+    expiresAt: Date,
+    refreshTokenExpiresAt: Date,
+    tokenType: { type: String, default: "Bearer" },
+    igUserId: String,
+    pageId: String,
+    pageAccessToken: String,
+}, credentialOpts);
+
+const oauth2Schema = new Schema({
+    credentials: oauth2CredentialsSchema,
+    config: Schema.Types.Mixed
+}, baseOpts);
+
+const apiKeyCredentialsSchema = new Schema({
+    apiKey: String,
+    apiToken: String,
+    accountSid: String,
+    subdomain: String,
+}, credentialOpts);
+
+const apiKeySchema = new Schema({
+    credentials: apiKeyCredentialsSchema,
+    config: Schema.Types.Mixed
+}, baseOpts);
+
+const basicSchema = new Schema({
+    credentials: {
+        username: String,
+        password: String,
+        basicToken: String,
+        id: String,
+    }
+}, baseOpts);
+
+const bearerSchema = new Schema({
+    credentials: {
+        token: String,
+    }
+}, baseOpts);
+
+const jwtSchema = new Schema({
+    credentials: {
+        token: String,
+        expiresAt: Date
+    },
+    config: {
+        issuer: String,
+        audience: String,
+        algorithm: String
+    }
+}, baseOpts);
+
+const hmacSchema = new Schema({
+    credentials: {
+        apiKey: String,
+        apiSecret: String,
+    },
+    config: {
+        algorithm: { type: String, default: "sha256" },
+        header: { type: String, default: "x-signature" }
+    }
+}, baseOpts);
+
+const customHeaderSchema = new Schema({
+    credentials: {
+        headers: {
+            type: Map,
+            of: String
+        }
+    }
+}, baseOpts);
+
+const mtlsSchema = new Schema({
+    credentials: {
+        cert: String,
+        key: String,
+        ca: String
+    }
+}, baseOpts);
+
+const cookieSchema = new Schema({
+    credentials: {
+        cookies: {
+            type: Map,
+            of: String
+        }
+    }
+}, baseOpts);
+
+const noAuthSchema = new Schema({}, baseOpts);
+
+ApiAuthenticationSchema.discriminator("oauth2", oauth2Schema);
+ApiAuthenticationSchema.discriminator("apiKey", apiKeySchema);
+ApiAuthenticationSchema.discriminator("basic", basicSchema);
+ApiAuthenticationSchema.discriminator("bearer", bearerSchema);
+ApiAuthenticationSchema.discriminator("jwt", jwtSchema);
+ApiAuthenticationSchema.discriminator("hmac", hmacSchema);
+ApiAuthenticationSchema.discriminator("customHeader", customHeaderSchema);
+ApiAuthenticationSchema.discriminator("mtls", mtlsSchema);
+ApiAuthenticationSchema.discriminator("cookie", cookieSchema);
+ApiAuthenticationSchema.discriminator("none", noAuthSchema);
+
+ApiAuthenticationSchema.methods.getSecrets = function () {
+    return { credentials: this.credentials, config: this.config };
+};
+ApiAuthenticationSchema.methods.getCredentials = async function () {
+    return this.credentials;
+};
+ApiAuthenticationSchema.methods._resolveProvider = async function () {
+    const getAuthProvider = requireDep("getAuthProvider", "ApiAuthenticators._resolveProvider");
+    await this.populate("provider");
+    const serviceProvider = getAuthProvider(this.provider?.name);
+    if (!serviceProvider) throw new Error(`Unsupported provider: ${this.provider?.name}`);
+    return serviceProvider;
+};
+ApiAuthenticationSchema.methods._plain = function (value) {
+    return value?.toObject?.() ?? value ?? {};
+};
+ApiAuthenticationSchema.methods._enrichedCredentials = function () {
+    const creds = { ...this._plain(this.credentials) };
+    const config = this._plain(this.config);
+    if (this.authType === "apiKey") {
+        creds.accountSid ??= config.AccountSid;
+        creds.subdomain ??= config.subdomain;
+    }
+    return creds;
+};
+ApiAuthenticationSchema.methods._isAccessTokenFresh = function () {
+    const { accessToken, expiresAt } = this._enrichedCredentials();
+    if (!accessToken || !expiresAt) return false;
+    return new Date(expiresAt).getTime() > Date.now() + TOKEN_EXPIRY_BUFFER_MS;
+};
+ApiAuthenticationSchema.methods.validateToken = async function () {
+    const serviceProvider = await this._resolveProvider();
+    return serviceProvider.validateToken(this._enrichedCredentials());
+};
+ApiAuthenticationSchema.methods.refreshToken = async function () {
+    const serviceProvider = await this._resolveProvider();
+    const providerSupportsRefresh = requireDep("providerSupportsRefresh", "ApiAuthenticators.refreshToken");
+    if (!providerSupportsRefresh(serviceProvider)) {
+        throw new Error(`Provider "${this.provider.name}" does not support token refresh`);
+    }
+    const newTokensRes = await serviceProvider.refreshToken(this._enrichedCredentials());
+    if (!newTokensRes.success) throw new Error(newTokensRes.error.message);
+    this.credentials = { ...this.credentials, ...newTokensRes.data };
+    await this.save();
+    return this;
+};
+ApiAuthenticationSchema.methods.ensureValidToken = async function () {
+    const serviceProvider = await this._resolveProvider();
+    const providerSupportsRefresh = requireDep("providerSupportsRefresh", "ApiAuthenticators.ensureValidToken");
+
+    if (this._isAccessTokenFresh()) return this;
+
+    if (await serviceProvider.validateToken(this.credentials)) return this;
+
+    if (!providerSupportsRefresh(serviceProvider)) {
+        throw new Error(`Invalid or expired credentials for ${this.provider.name}; re-authentication required`);
+    }
+
+    return this.refreshToken();
+};
+ApiAuthenticationSchema.methods.hasAllScopes = function (scopes) {
+    for (const item of scopes) {
+        if (!this.scope.includes(item)) {
+            return false;
+        }
+    }
+    return true;
+};
+
+export { ApiAuthenticationSchema };
+export const ApiAuthenticators = defineModel("ApiAuthenticators", ApiAuthenticationSchema, "ApiAuthenticators");

package/src/models/index.js

@@ -5,3 +5,27 @@ export { UsageLog, UsageLogSchema } from "./UsageLogs.js";
 export { Conversation, ConversationSchema } from "./Conversations.js";
 export { Campaign, CampaignSchema, Task, TaskSchema } from "./Campaign.js";
 export { Trigger, TriggerSchema } from "./Triggers.js";
+export { User, ScopesEnum, RoleScopes } from "./User.js";
+export { AgentModel } from "./Agent.js";
+export { Channel, ChannelCapabilityDefaults } from "./Channels.js";
+export { CallSession } from "./CallSessions.js";
+export { Plan } from "./Plans.js";
+export { Api, Providers } from "./ExternalServiceProviders.js";
+export { Template } from "./market.js";
+export { Message, MessageSession } from "./Messages.js";
+export { Lead, LeadTemplate } from "./Leads.js";
+export { Log } from "./Log.js";
+export { BillingLog } from "./BillingLogs.js";
+export { ApiAuthenticators, ApiAuthenticationSchema } from "./apiAuthenticator.js";
+export { DemonstrationModel } from "./Demonstarations.js";
+export { Action } from "./Action.js";
+export { Collection } from "./Collection.js";
+export { Node, NodeModel } from "./InbuiltNodes.js";
+export { Integration } from "./Integrations.js";
+export { Job } from "./Job.js";
+export { Notification } from "./notifications.js";
+export { Ticket } from "./Tickets.js";
+export { Document } from "./Document.js";
+export { Data } from "./Data.js";
+export { Workflow, WorkflowSchema } from "./Workflow.js";
+export { WorkflowLogs } from "./WorkflowLogs.js";

package/src/models/market.js

@@ -0,0 +1,66 @@
+// models/channel.js
+import { Schema } from "mongoose";
+import { defineModel } from "../runtime.js";
+
+const baseOpts = { _id: false };      // subdocs don’t need their own _id
+const docOpts = { timestamps: true, discriminatorKey: 'type' };
+
+/* ───────────────────────────── Base Channel ───────────────────────────── */
+const TemplateBaseSchema = new Schema(
+    {
+        name: { type: String, required: true, trim: true },
+        createdBy: { type: Schema.Types.ObjectId, ref: "Users" },
+        type: { type: String, enum: ['agent', 'action'], required: true },
+        status: { type: String, default: 'disabled' },   // enabled | disabled | error
+        description: String, //can be removed as tool already has it             
+        imageUrl: String,
+        tags: [String],
+        version: String,
+        applicableSectors: [String], //business sectors the tool is applicable for, useful for filtering in marketplace
+        isPublic: { type: Boolean, default: false },
+        UIElements: Schema.Types.Mixed,
+        isFeatured: { type: Boolean, default: false },
+    },
+    docOpts
+);
+export const Template = defineModel('StandardProduct', TemplateBaseSchema, 'StandardProduct');
+
+/* ───────────────────────────── Agent Template ──────────────────────────── */
+const AgentData = new Schema(
+    {
+        personalInfo: {
+            name: String,
+            systemPrompt: {
+                role: String,
+                objective: String,
+                instructionsAndWorkflow: String,
+                constraintsAndRules: String
+            },
+            model: { type: String, default: 'gpt-4.1-mini' },
+            temperature: { type: Number, default: 0.5 },
+        },
+        collections: [{ type: Schema.Types.ObjectId, ref: 'Collection' }],
+        actions: [{ type: Schema.Types.ObjectId, ref: 'StandardProduct' }],
+        facets: [String],
+    },
+    baseOpts
+);
+Template.discriminator('agent', new Schema({ data: AgentData, config: Schema.Types.Mixed }, docOpts));
+/* ─────────────────────────── Action Template ─────────────────────────── */
+const ActionData = new Schema(
+    {
+        name: String,
+        description: String,
+        async: { type: Boolean, default: true },
+        needsApproval: Boolean, // Knowledge fetching doesn't need approval
+        parameters: Schema.Types.Mixed,
+        functionString: String,
+        errorFunction: String,
+        UI: Schema.Types.Mixed,
+    },
+    baseOpts
+);
+const ActionConfig = new Schema({
+    orgDefinedParams: Schema.Types.Mixed,
+}, baseOpts);
+Template.discriminator('action', new Schema({ data: ActionData, config: ActionConfig }, docOpts));

package/src/models/notifications.js

@@ -0,0 +1,15 @@
+// mongodb schema for notificatiosn that contains the following fields => head, body,type,attachments, status timestamps
+import { Schema, Types } from "mongoose";
+import { defineModel } from "../runtime.js";
+const NotificationSchema = new Schema(
+    {
+        business: { type: Types.ObjectId, ref: 'Businesses' },
+        head: String,
+        body: String,
+        type: String,
+        attachments: Schema.Types.Mixed,
+        status: { type: String, default: "unseen" },
+    },
+    { timestamps: true }
+);
+export const Notification = defineModel('Notification', NotificationSchema, 'Notification');

package/src/runtime.js

@@ -19,6 +19,10 @@ export function defineModel(name, schema, collection) {
 const deps = {
     /** ({ topic, message, acks }) => Promise<void> — the service's Kafka producer. */
     sendKafkaMessage: null,
+    /** (providerName) => host OAuth/API provider instance. */
+    getAuthProvider: null,
+    /** (provider) => boolean — whether the host provider implements refreshToken. */
+    providerSupportsRefresh: null,
 };
 
 export function configureSchemas(next = {}) {