@mastra/core 0.1.0 → 0.1.2

package/dist/data-access/index.d.ts

@@ -0,0 +1,350 @@
+import { Prisma, PrismaClient, Credential } from '@prisma-app/client';
+import { FilterObject } from '../lib/query-builder/types';
+import { prisma } from '../prisma/client';
+import { RecordService } from '../service/service.record';
+import { CredentialValue } from '../types';
+export declare class DataLayer {
+    db: PrismaClient;
+    recordService: RecordService<typeof prisma>;
+    constructor({ url }: {
+        url: string;
+        provider: string;
+    });
+    createConnection({ connection, credential, }: {
+        connection: Prisma.ConnectionUncheckedCreateInput;
+        credential: Omit<Prisma.CredentialUncheckedCreateInput, 'k_id'>;
+    }): Promise<{
+        id: string;
+        name: string;
+        issues: string[];
+        syncConfig: Prisma.JsonValue | null;
+        connectionId: string;
+        createdAt: Date;
+        updatedAt: Date | null;
+        lastSyncAt: Date | null;
+        subscriptionId: string | null;
+    } & {
+        credential: Credential;
+    }>;
+    deleteConnection({ connectionId }: {
+        connectionId: string;
+    }): Promise<{
+        id: string;
+        name: string;
+        issues: string[];
+        syncConfig: Prisma.JsonValue | null;
+        connectionId: string;
+        createdAt: Date;
+        updatedAt: Date | null;
+        lastSyncAt: Date | null;
+        subscriptionId: string | null;
+    }>;
+    getConnection({ connectionId, name, }: {
+        name: string;
+        connectionId: string;
+    }): Promise<{
+        id: string;
+        name: string;
+        issues: string[];
+        syncConfig: Prisma.JsonValue | null;
+        connectionId: string;
+        createdAt: Date;
+        updatedAt: Date | null;
+        lastSyncAt: Date | null;
+        subscriptionId: string | null;
+    } | null>;
+    getConnectionsByIntegrationName({ name }: {
+        name: string;
+    }): Promise<{
+        id: string;
+        name: string;
+        issues: string[];
+        syncConfig: Prisma.JsonValue | null;
+        connectionId: string;
+        createdAt: Date;
+        updatedAt: Date | null;
+        lastSyncAt: Date | null;
+        subscriptionId: string | null;
+    }[]>;
+    getAllConnections(): Promise<{
+        name: string;
+        connectionId: string;
+    }[]>;
+    getConnectionById({ k_id }: {
+        k_id: string;
+    }): Promise<{
+        id: string;
+        name: string;
+        issues: string[];
+        syncConfig: Prisma.JsonValue | null;
+        connectionId: string;
+        createdAt: Date;
+        updatedAt: Date | null;
+        lastSyncAt: Date | null;
+        subscriptionId: string | null;
+    } | null>;
+    getCredentialsByConnection(k_id: string): Promise<{
+        connection: {
+            id: string;
+            name: string;
+            issues: string[];
+            syncConfig: Prisma.JsonValue | null;
+            connectionId: string;
+            createdAt: Date;
+            updatedAt: Date | null;
+            lastSyncAt: Date | null;
+            subscriptionId: string | null;
+        };
+    } & {
+        id: string;
+        type: string;
+        value: Prisma.JsonValue;
+        scope: string[];
+        k_id: string;
+    }>;
+    updateConnectionCredential({ k_id, token, }: {
+        k_id: string;
+        token: CredentialValue;
+    }): Promise<{
+        id: string;
+        type: string;
+        value: Prisma.JsonValue;
+        scope: string[];
+        k_id: string;
+    }>;
+    createEntity({ connectionId, type, k_id, }: {
+        k_id: string;
+        type: string;
+        connectionId: string;
+    }): Promise<{
+        id: string;
+        type: string;
+        createdAt: Date;
+        updatedAt: Date | null;
+        createdBy: string;
+        k_id: string;
+        lastSyncId: string | null;
+    }>;
+    getEntityById(entityId: string): Promise<{
+        id: string;
+        type: string;
+        createdAt: Date;
+        updatedAt: Date | null;
+        createdBy: string;
+        k_id: string;
+        lastSyncId: string | null;
+    }>;
+    addPropertiesToEntity({ entityId, properties, }: {
+        entityId: string;
+        properties: Prisma.PropertyCreateInput[];
+    }): Promise<{
+        id: string;
+        type: string;
+        createdAt: Date;
+        updatedAt: Date | null;
+        createdBy: string;
+        k_id: string;
+        lastSyncId: string | null;
+    }>;
+    getEntityRecordsByConnectionAndType({ k_id, type, }: {
+        k_id: string;
+        type: string;
+    }): Promise<({
+        properties: {
+            id: string;
+            name: string;
+            displayName: string;
+            visible: boolean;
+            config: Prisma.JsonValue | null;
+            description: string | null;
+            type: import("@prisma-app/client").$Enums.PropertyType;
+            order: number;
+            modifiable: boolean;
+            parentId: string | null;
+            entityId: string | null;
+        }[];
+        records: {
+            id: string;
+            externalId: string | null;
+            data: Prisma.JsonValue;
+            source: string;
+            entityType: string;
+            entityId: string | null;
+            status: import("@prisma-app/client").$Enums.RecordStatus;
+            enrichmentStatus: import("@prisma-app/client").$Enums.RecordEnrichmentStatus;
+            deletedAt: Date | null;
+            createdAt: Date;
+            updatedAt: Date | null;
+        }[];
+    } & {
+        id: string;
+        type: string;
+        createdAt: Date;
+        updatedAt: Date | null;
+        createdBy: string;
+        k_id: string;
+        lastSyncId: string | null;
+    }) | null>;
+    getEntityByConnectionAndType({ k_id, type, }: {
+        k_id: string;
+        type: string;
+    }): Promise<{
+        id: string;
+        type: string;
+        createdAt: Date;
+        updatedAt: Date | null;
+        createdBy: string;
+        k_id: string;
+        lastSyncId: string | null;
+    } | null>;
+    updateEntityLastSyncId({ entityId, syncId, }: {
+        entityId: string;
+        syncId: string;
+    }): Promise<{
+        id: string;
+        type: string;
+        createdAt: Date;
+        updatedAt: Date | null;
+        createdBy: string;
+        k_id: string;
+        lastSyncId: string | null;
+    }>;
+    deleteEntityById(entityId: string): Promise<{
+        id: string;
+        type: string;
+        createdAt: Date;
+        updatedAt: Date | null;
+        createdBy: string;
+        k_id: string;
+        lastSyncId: string | null;
+    }>;
+    /**
+     * Creates new records for a entity, or updates existing record 'data' if it already exists
+     * @param entityId
+     * @param records
+     */
+    mergeExternalRecordsForEntity({ entityId, records, }: {
+        entityId: string;
+        records: {
+            externalId: string;
+            data: Record<string, any>;
+            entityType?: string;
+        }[];
+    }): Promise<[Prisma.BatchPayload | undefined, number | undefined] | undefined>;
+    updateConnectionCredentials({ k_id, ...update }: Prisma.CredentialUpdateInput & {
+        k_id: string;
+    }): Promise<{
+        id: string;
+        type: string;
+        value: Prisma.JsonValue;
+        scope: string[];
+        k_id: string;
+    }>;
+    getRecords<T extends string | number | symbol>({ entityType, k_id, filters, sort, }: {
+        entityType: string;
+        k_id: string;
+        filters?: FilterObject<T>;
+        sort?: string[];
+    }): Promise<any>;
+    getRecordByPropertyNameAndValues({ propertyName, propertValues, type, connectionId, }: {
+        propertyName: string;
+        propertValues: string[];
+        type?: string;
+        connectionId: string;
+    }): Promise<{
+        id: string;
+        externalId: string | null;
+        data: Prisma.JsonValue;
+        source: string;
+        entityType: string;
+        entityId: string | null;
+        status: import("@prisma-app/client").$Enums.RecordStatus;
+        enrichmentStatus: import("@prisma-app/client").$Enums.RecordEnrichmentStatus;
+        deletedAt: Date | null;
+        createdAt: Date;
+        updatedAt: Date | null;
+    }[]>;
+    getRecordByPropertyNameAndValue({ propertyName, propertyValue, type, connectionId, }: {
+        propertyName: string;
+        propertyValue: string;
+        type: string;
+        connectionId: string;
+    }): Promise<{
+        id: string;
+        externalId: string | null;
+        data: Prisma.JsonValue;
+        source: string;
+        entityType: string;
+        entityId: string | null;
+        status: import("@prisma-app/client").$Enums.RecordStatus;
+        enrichmentStatus: import("@prisma-app/client").$Enums.RecordEnrichmentStatus;
+        deletedAt: Date | null;
+        createdAt: Date;
+        updatedAt: Date | null;
+    } | null>;
+    getRecordsByPropertyName({ propertyName, connectionId, }: {
+        propertyName: string;
+        connectionId: string;
+    }): Promise<{
+        id: string;
+        externalId: string | null;
+        data: Prisma.JsonValue;
+        source: string;
+        entityType: string;
+        entityId: string | null;
+        status: import("@prisma-app/client").$Enums.RecordStatus;
+        enrichmentStatus: import("@prisma-app/client").$Enums.RecordEnrichmentStatus;
+        deletedAt: Date | null;
+        createdAt: Date;
+        updatedAt: Date | null;
+    }[]>;
+    setConnectionError({ k_id, error }: {
+        k_id: string;
+        error: string;
+    }): Promise<{
+        id: string;
+        name: string;
+        issues: string[];
+        syncConfig: Prisma.JsonValue | null;
+        connectionId: string;
+        createdAt: Date;
+        updatedAt: Date | null;
+        lastSyncAt: Date | null;
+        subscriptionId: string | null;
+    }>;
+    setConnectionSubscriptionId({ k_id, subscriptionId, }: {
+        k_id: string;
+        subscriptionId: string;
+    }): Promise<{
+        id: string;
+        name: string;
+        issues: string[];
+        syncConfig: Prisma.JsonValue | null;
+        connectionId: string;
+        createdAt: Date;
+        updatedAt: Date | null;
+        lastSyncAt: Date | null;
+        subscriptionId: string | null;
+    }>;
+    syncData({ connectionId, name, data, type, properties, lastSyncId, }: {
+        name: string;
+        properties: Prisma.PropertyCreateInput[];
+        connectionId: string;
+        data: any;
+        type: string;
+        lastSyncId?: string;
+    }): Promise<void>;
+    getConnectionsBySubscriptionId({ subscriptionId, }: {
+        subscriptionId: string;
+    }): Promise<{
+        id: string;
+        name: string;
+        issues: string[];
+        syncConfig: Prisma.JsonValue | null;
+        connectionId: string;
+        createdAt: Date;
+        updatedAt: Date | null;
+        lastSyncAt: Date | null;
+        subscriptionId: string | null;
+    }[]>;
+}

package/dist/framework.d.ts

@@ -0,0 +1,116 @@
+import { DataLayer } from './data-access';
+import { Integration } from './integration';
+import { Config, IntegrationApi, IntegrationApiExcutorParams, IntegrationContext, IntegrationEvent, Routes, ZodeSchemaGenerator } from './types';
+import { Blueprint } from './workflows/types';
+import { NextRequest, NextResponse } from 'next/server';
+import { IntegrationMap } from './generated-types';
+import { Prisma } from '@prisma-app/client';
+import { z, ZodSchema } from 'zod';
+export declare class Framework<C extends Config = Config> {
+    globalEvents: Map<string, Record<string, IntegrationEvent<any>>>;
+    globalEventHandlers: any[];
+    globalApis: Map<string, Record<string, IntegrationApi<any>>>;
+    integrations: Map<string, Integration>;
+    dataLayer: DataLayer;
+    config: C;
+    static init<C extends Config = Config>(config: C): Framework<C>;
+    constructor({ dataLayer, config }: {
+        dataLayer: DataLayer;
+        config: C;
+    });
+    connectedIntegrations({ context, }: {
+        context: {
+            connectionId: string;
+        };
+    }): Promise<Integration<unknown>[]>;
+    get routes(): Record<Routes, string>;
+    __registerIntgeration(definition: Integration): void;
+    __registerEvents({ events, integrationName, }: {
+        events: Record<string, IntegrationEvent<any>>;
+        integrationName?: string;
+    }): void;
+    __registerApis({ apis, integrationName, }: {
+        apis: IntegrationApi[];
+        integrationName?: string;
+    }): void;
+    availableIntegrations(): {
+        name: string;
+        integration: Integration<unknown>;
+    }[];
+    getIntegration<T extends keyof IntegrationMap>(name: T): IntegrationMap[T];
+    getGlobalEvents(): Map<string, Record<string, IntegrationEvent<any>>>;
+    getSystemEvents(): Record<string, IntegrationEvent<any>>;
+    getEventsByIntegration(name: string): Record<string, IntegrationEvent<any>> | undefined;
+    getGlobalEventHandlers(): any[];
+    getApis(): Map<string, Record<string, IntegrationApi<any>>>;
+    getSystemApis(): Record<string, IntegrationApi<any>> | undefined;
+    getApisByIntegration(name: string, includeHidden?: boolean): Record<string, IntegrationApi<any>> | undefined;
+    authenticatableIntegrations(): {
+        name: string;
+        integration: Integration<unknown>;
+    }[];
+    authenticator(name: string): import("./authenticator").IntegrationAuth;
+    connectIntegrationByCredential({ name, connectionId, credential, }: {
+        name: string;
+        connectionId: string;
+        credential: Omit<Prisma.CredentialUncheckedCreateInput, 'k_id'>;
+    }): Promise<void>;
+    disconnectIntegration({ name, connectionId, }: {
+        name: string;
+        connectionId: string;
+    }): Promise<void>;
+    callApi({ integrationName, api, payload, }: {
+        integrationName?: string;
+        api: string;
+        payload: IntegrationApiExcutorParams;
+    }): Promise<Record<string, any>>;
+    subscribeEvent({ id, interval, timeout, }: {
+        id: string;
+        interval?: number;
+        timeout?: number;
+    }): Promise<{
+        status: string;
+        startedAt: string;
+        endedAt: string;
+    } | null>;
+    triggerEvent<KEY extends keyof C['workflows']['systemEvents'], SYSTEM_EVENT_SCHEMA extends C['workflows']['systemEvents'][KEY]['schema']>({ key, data, user, integrationName, }: {
+        integrationName?: string;
+        key: KEY;
+        data: SYSTEM_EVENT_SCHEMA extends ZodSchema ? z.infer<SYSTEM_EVENT_SCHEMA> : SYSTEM_EVENT_SCHEMA extends ZodeSchemaGenerator ? z.infer<Awaited<ReturnType<SYSTEM_EVENT_SCHEMA>>> : never;
+        user?: {
+            connectionId: string;
+            [key: string]: any;
+        };
+    }): Promise<{
+        event: any;
+        workflowEvent?: any;
+    }>;
+    triggerSystemEvent<T = Record<string, any>>({ key, data, user, }: {
+        key: string;
+        data: T;
+        user?: {
+            connectionId: string;
+            [key: string]: any;
+        };
+    }): Promise<import("inngest/types").SendEventOutput<{
+        id: string;
+    }>>;
+    createRouter(): {
+        makeWebhookUrl: ({ event, name, }: {
+            name: string;
+            event: string;
+        }) => string;
+        makeRedirectURI: () => string;
+        makeConnectURI: (props: {
+            name: string;
+            connectionId: string;
+            clientRedirectPath: string;
+        }) => string;
+        registerRoutes: () => (req: NextRequest) => NextResponse<unknown> | Promise<Response>;
+    };
+    runBlueprint: ({ blueprint, dataCtx, ctx, }: {
+        blueprint: Blueprint;
+        dataCtx?: any;
+        ctx: IntegrationContext;
+    }) => Promise<void>;
+}

package/dist/generated-types/index.d.ts

@@ -0,0 +1,4 @@
+import type { Integration } from '../integration';
+export interface IntegrationMap {
+    [s: string]: Integration;
+}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export * from './workflows/types';
+export { IntegrationError } from './utils/errors';
+export { DataLayer } from './data-access';
+export { registerRoutes } from './next';
+export * from './types';
+export * from './lib';
+export { Integration } from './integration';
+export { IntegrationCredentialType } from './types';
+export { PropertyType, Connection, Credential, Entity, Property, Record, } from '@prisma-app/client';
+export { IntegrationAuth } from './authenticator';
+export * from './utils';
+export * from './next/utils';
+export * from './schemas';
+export * from './sync-factory';
+export { Framework } from './framework';
+export * from './generated-types';

package/dist/index.js

@@ -0,0 +1,8 @@
+
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./core.cjs.production.min.js')
+} else {
+  module.exports = require('./core.cjs.development.js')
+}

package/dist/integration.d.ts

@@ -0,0 +1,100 @@
+import { EventHandlerReturnType, IntegrationApi, IntegrationCredentialType, IntegrationEvent, MakeWebhookURL } from './types';
+import { ZodSchema } from 'zod';
+import { DataLayer } from './data-access';
+import { IntegrationAuth } from './authenticator';
+import { Connection } from '@prisma-app/client';
+import { FilterObject } from './lib';
+export type IntegrationConfig = {
+    name: string;
+    logoUrl: string;
+    scopes?: string[];
+    authType?: IntegrationCredentialType;
+    authConnectionOptions?: ZodSchema;
+    [key: string]: any;
+};
+export type CoreIntegrationPresets = {
+    redirectURI: string;
+};
+/**
+ * @params T - The type of the client that the integration provides
+ */
+export declare class Integration<T = unknown> {
+    name: string;
+    logoUrl: string;
+    categories: string[];
+    description: string;
+    dataLayer?: DataLayer;
+    config: Omit<IntegrationConfig, 'name' | 'logoUrl'> & {
+        [key: string]: any;
+    };
+    availableScopes?: {
+        key: string;
+        description: string;
+    }[];
+    events: Record<string, IntegrationEvent<any>>;
+    apis: Record<string, IntegrationApi<any>>;
+    entityTypes: Record<string, string>;
+    corePresets: CoreIntegrationPresets;
+    constructor(config: IntegrationConfig);
+    getConfig(): Omit<IntegrationConfig, "name" | "logoUrl"> & {
+        [key: string]: any;
+    };
+    getClientZodSchema(): any;
+    getCommentsForClientApis(): Record<string, {
+        comment: string;
+        doc?: string;
+    }>;
+    getBaseClient(): any;
+    getApiClient(params: {
+        connectionId: string;
+    }): Promise<any>;
+    getApi({ connectionId }: {
+        connectionId: string;
+    }): Promise<any>;
+    _convertApiClientToSystemApis: () => Promise<void>;
+    getAuthenticator(): IntegrationAuth;
+    makeClient: (params: {
+        connectionId: string;
+    }) => Promise<T>;
+    attachDataLayer({ dataLayer }: {
+        dataLayer: DataLayer;
+    }): void;
+    getEventHandlers: ({ makeWebhookUrl, }: {
+        makeWebhookUrl: MakeWebhookURL;
+    }) => EventHandlerReturnType[];
+    registerApis(): {};
+    getApis(): Record<string, IntegrationApi<any>>;
+    registerEvents<T extends Integration>(): Record<string, IntegrationEvent<T>>;
+    getEvents<T extends Integration>(): Record<string, IntegrationEvent<T>>;
+    query<T extends string | number | symbol>(props: {
+        connectionId: string;
+        entityType: any;
+        filters?: FilterObject<T>;
+        sort?: string[];
+    }): Promise<any>;
+    getEvent(name: string): IntegrationEvent<any>;
+    processWebhookRequest(params: {
+        reqBody: any;
+        event: string;
+        connectionsBySubscriptionId: (subscriptionId: string) => Promise<Connection[]>;
+    }): Promise<void>;
+    triggerEvent<T = Record<string, any>>({ key, data, user, }: {
+        key: string;
+        data: T;
+        user?: {
+            connectionId: string;
+            [key: string]: any;
+        };
+    }): Promise<import("inngest/types").SendEventOutput<{
+        id: string;
+    }>>;
+    test({ connectionId, }: {
+        connectionId: string;
+    }): Promise<string | null>;
+    onConnectionCreated({ connection, }: {
+        connection: Connection;
+    }): Promise<any>;
+    onDisconnect({ connectionId, }: {
+        connectionId: string;
+    }): Promise<any>;
+}

package/dist/lib/index.d.ts

@@ -0,0 +1,5 @@
+export * from './query-builder/types';
+export * from './query-builder/schema';
+export * from './query-builder/constants';
+export * from './query-builder/utils';
+export * from './utils/object';

package/dist/lib/query-builder/constants.d.ts

@@ -0,0 +1,16 @@
+import { PropertyType } from '@prisma-app/client';
+import { FilterOperators } from './types';
+export interface SortField {
+    type: string;
+    name: string;
+    displayName: string;
+    config?: Record<string, any>;
+}
+export interface SortLogic {
+    field: SortField;
+    mode: 'ascending' | 'descending';
+}
+export declare const fieldsWithCommaSeparatedValues: PropertyType[];
+export declare const FieldTypePrimitiveMap: Record<PropertyType, string>;
+export declare const SORT_MODE_TO_ABBR: Record<SortLogic['mode'], string>;
+export declare const FilterOperatorToSQL: Record<FilterOperators, string>;

package/dist/lib/query-builder/filters/sql.d.ts

@@ -0,0 +1,8 @@
+import { FilterClauseArgs } from '../types';
+/**
+ * Get the SQL filter clause for the given filters.
+ * @param filters - Filters to apply.
+ * @param fields - Optional. JSON fields with associated types to apply filters on.
+ * @param parentTableRef - Parent table reference to apply filters on.
+ */
+export declare const getFilterClauseSQL: ({ filters, fields, parentTableRef, }: FilterClauseArgs<string>) => string;

package/dist/lib/query-builder/schema.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import { FilterOperators } from './types';
+type ValueOf<T> = Required<T>[keyof T];
+export declare const filterQuerySchema: z.ZodObject<Record<ValueOf<typeof FilterOperators>, any>, "strip", z.ZodTypeAny, {
+    is?: any;
+    eq?: any;
+    not_eq?: any;
+    contains?: any;
+    in?: any;
+    not_in?: any;
+    gt?: any;
+    lt?: any;
+    not_contains?: any;
+    gte?: any;
+    lte?: any;
+    op?: any;
+    set?: any;
+    not_set?: any;
+}, {
+    is?: any;
+    eq?: any;
+    not_eq?: any;
+    contains?: any;
+    in?: any;
+    not_in?: any;
+    gt?: any;
+    lt?: any;
+    not_contains?: any;
+    gte?: any;
+    lte?: any;
+    op?: any;
+    set?: any;
+    not_set?: any;
+}>;
+export declare const sortQuerySchema: z.ZodEffects<z.ZodString, string[] | undefined, string>;
+export {};

package/dist/lib/query-builder/sorts/sql.d.ts

@@ -0,0 +1,7 @@
+import { SortClauseArgs } from '../types';
+/**
+ * Get the SQL sort clause for the given sort fields.
+ * A sort clause is an array of strings where each string is a field to sort by.
+ * e.g. ["field1 ASC", "field2 DESC"] will sort by field1 in ascending order and field2 in descending order.
+ */
+export declare const getSortClauseSQL: ({ sort, parentTableRef, fields, }: SortClauseArgs) => string[];