@mastra/core 0.1.0 → 0.1.2

package/dist/sync-fixtures/stripe.d.ts

@@ -0,0 +1,92 @@
+import { z } from 'zod';
+/**
+ * Prices define the unit cost, currency, and (optional) billing cycle for both recurring and one-time purchases of products.
+ * [Products](https://stripe.com/docs/api#products) help you track inventory or provisioning, and prices help you track payment terms. Different physical goods or levels of service should be represented by products, and pricing options should be represented by prices. This approach lets you change prices without having to change your provisioning scheme.
+ *
+ * For example, you might have a single "gold" product that has prices for $10/month, $100/year, and €9 once.
+ *
+ * Related guides: [Set up a subscription](https://stripe.com/docs/billing/subscriptions/set-up-subscription), [create an invoice](https://stripe.com/docs/billing/invoices/create), and more about [products and prices](https://stripe.com/docs/products-prices/overview).
+ */
+export type price = {
+    /**
+     * Whether the price can be used for new purchases.
+     */
+    active: boolean;
+    /**
+     * Describes how to compute the price per period. Either `per_unit` or `tiered`. `per_unit` indicates that the fixed amount (specified in `unit_amount` or `unit_amount_decimal`) will be charged per unit in `quantity` (for prices with `usage_type=licensed`), or per unit of total usage (for prices with `usage_type=metered`). `tiered` indicates that the unit pricing will be computed using a tiering strategy as defined using the `tiers` and `tiers_mode` attributes.
+     */
+    billing_scheme: 'per_unit' | 'tiered';
+    /**
+     * Time at which the object was created. Measured in seconds since the Unix epoch.
+     */
+    created: number;
+    /**
+     * Three-letter [ISO currency code](https://www.iso.org/iso-4217-currency-codes.html), in lowercase. Must be a [supported currency](https://stripe.com/docs/currencies).
+     */
+    currency: string;
+    /**
+     * Unique identifier for the object.
+     */
+    id: string;
+    /**
+     * Has the value `true` if the object exists in live mode or the value `false` if the object exists in test mode.
+     */
+    livemode: boolean;
+    /**
+     * A lookup key used to retrieve prices dynamically from a static string. This may be up to 200 characters.
+     */
+    lookup_key?: string | null;
+    /**
+     * Set of [key-value pairs](https://stripe.com/docs/api/metadata) that you can attach to an object. This can be useful for storing additional information about the object in a structured format.
+     */
+    metadata: {
+        [key: string]: string;
+    };
+    /**
+     * A brief description of the price, hidden from customers.
+     */
+    nickname?: string | null;
+    /**
+     * Only required if a [default tax behavior](https://stripe.com/docs/tax/products-prices-tax-categories-tax-behavior#setting-a-default-tax-behavior-(recommended)) was not provided in the Stripe Tax settings. Specifies whether the price is considered inclusive of taxes or exclusive of taxes. One of `inclusive`, `exclusive`, or `unspecified`. Once specified as either `inclusive` or `exclusive`, it cannot be changed.
+     */
+    tax_behavior?: ('exclusive' | 'inclusive' | 'unspecified') | null;
+    /**
+     * Defines if the tiering price should be `graduated` or `volume` based. In `volume`-based tiering, the maximum quantity within a period determines the per unit price. In `graduated` tiering, pricing can change as the quantity grows.
+     */
+    tiers_mode?: ('graduated' | 'volume') | null;
+    /**
+     * One of `one_time` or `recurring` depending on whether the price is for a one-time purchase or a recurring (subscription) purchase.
+     */
+    type: 'one_time' | 'recurring';
+    /**
+     * The unit amount in cents (or local equivalent) to be charged, represented as a whole integer if possible. Only set if `billing_scheme=per_unit`.
+     */
+    unit_amount?: number | null;
+    /**
+     * The unit amount in cents (or local equivalent) to be charged, represented as a decimal string with at most 12 decimal places. Only set if `billing_scheme=per_unit`.
+     */
+    unit_amount_decimal?: string | null;
+};
+export declare const priceSchema: z.ZodSchema<price>;
+type GetPricesPriceResponse = price;
+type GetPricesResponse = {
+    /**
+     * Details about each object.
+     */
+    data: Array<price>;
+    /**
+     * True if this list has another page of items after this one that can be fetched.
+     */
+    has_more: boolean;
+    /**
+     * String representing the object's type. Objects of the same type share the same value. Always has the value `list`.
+     */
+    object: 'list';
+    /**
+     * The URL where this list can be accessed.
+     */
+    url: string;
+};
+export declare const getPricesPriceResponseSchema: z.ZodSchema<GetPricesPriceResponse>;
+export declare const getPricesResponseSchema: z.ZodSchema<GetPricesResponse>;
+export {};

package/dist/types.d.ts

@@ -0,0 +1,367 @@
+import { OAuth2Token } from '@badgateway/oauth2-client';
+import { BaseContext } from 'inngest';
+import { ZodSchema } from 'zod';
+import { Integration } from './integration';
+interface WorkflowConfig {
+    blueprintDirPath: string;
+    systemApis: Omit<IntegrationApi, 'integrationName'>[];
+    systemEvents: {
+        [key: string]: IntegrationEvent;
+    };
+}
+export interface Config {
+    name: string;
+    packageManager?: string;
+    systemHostURL: string;
+    routeRegistrationPath: string;
+    db: {
+        provider: string;
+        uri: string;
+    };
+    workflows: WorkflowConfig;
+    integrations: Integration[];
+    env?: {
+        provider?: 'local' | 'vercel';
+        file?: string;
+    };
+}
+export type IntegrationContext = {
+    connectionId: string;
+};
+export type SchemaFieldOptions = {
+    options: {
+        [parentValue: string]: {
+            value: string;
+            label: string;
+        }[];
+    };
+    parentField: string;
+} | {
+    options: {
+        value: string;
+        label: string;
+    }[];
+    parentField?: never;
+} | {
+    options: undefined;
+    parentField?: never;
+};
+export type frameWorkIcon = {
+    icon: string;
+    alt: string;
+};
+export interface IntegrationApiExcutorParams<T extends Record<string, any> = Record<string, any>> {
+    data: T;
+}
+export type ZodeSchemaGenerator = ({ ctx, }: {
+    ctx: IntegrationContext;
+}) => Promise<ZodSchema>;
+export type EventSchema = ZodSchema | ZodeSchemaGenerator;
+/**
+ * @param T - the type of the Integration Instance
+ */
+type IntegrationEventHandler<T extends Integration = Integration> = {
+    handler?: EventHandler<T>;
+};
+export type IntegrationEvent<T extends Integration = Integration> = RefinedIntegrationEvent & IntegrationEventHandler<T>;
+export type IntegrationApi<IN extends Record<string, any> = Record<string, any>, OUT extends Record<string, any> = Record<string, any>> = {
+    integrationName: string;
+    schema: ZodSchema<IN> | (({ ctx }: {
+        ctx: IntegrationContext;
+    }) => Promise<ZodSchema<IN>>);
+    outputSchema?: ZodSchema | (({ ctx }: {
+        ctx: IntegrationContext;
+    }) => Promise<ZodSchema<OUT>>);
+    type: string;
+    label: string;
+    getSchemaOptions?: ({ ctx, }: {
+        ctx: IntegrationContext;
+    }) => Promise<Record<string, SchemaFieldOptions>>;
+    icon?: frameWorkIcon;
+    description: string;
+    documentation?: string;
+    category?: string;
+    executor: (params: IntegrationApiExcutorParams<IN>) => Promise<OUT>;
+    isHidden?: boolean;
+};
+export declare enum IntegrationErrors {
+    BROKEN_CONNECTION = "BROKEN_CONNECTION",
+    MISSING_SCOPES = "MISSING_SCOPES"
+}
+export interface IntegrationApiExcutorParams<T> {
+    data: T;
+    ctx: IntegrationContext;
+}
+export type RefinedIntegrationApi<T = unknown> = Omit<IntegrationApi, 'getSchemaOptions'> & {
+    schemaOptions: Record<string, SchemaFieldOptions>;
+    zodSchema: ZodSchema<T>;
+    zodOutputSchema: ZodSchema<T>;
+};
+export type RefinedIntegrationEvent<T = unknown> = {
+    schema: EventSchema;
+    key?: string;
+    integrationName?: string;
+    label?: string;
+    description?: string;
+    getSchemaOptions?: ({ ctx, }: {
+        ctx: IntegrationContext;
+    }) => Promise<Record<string, SchemaFieldOptions>>;
+    zodSchema?: ZodSchema<T>;
+};
+export declare enum IntegrationCredentialType {
+    OAUTH = "OAUTH",
+    API_KEY = "API_KEY"
+}
+export declare const IntegrationFieldTypeEnum: {
+    readonly SINGLE_LINE_TEXT: "SINGLE_LINE_TEXT";
+    readonly LONG_TEXT: "LONG_TEXT";
+    readonly RICH_TEXT: "RICH_TEXT";
+    readonly SINGLE_SELECT: "SINGLE_SELECT";
+    readonly MULTI_SELECT: "MULTI_SELECT";
+    readonly CREATABLE_SELECT: "CREATABLE_SELECT";
+    readonly CHECKBOX: "CHECKBOX";
+    readonly DATE: "DATE";
+    readonly USER: "USER";
+    readonly BADGE_LIST: "BADGE_LIST";
+    readonly CURRENCY: "CURRENCY";
+    readonly URL: "URL";
+    readonly PHONE: "PHONE";
+    readonly CONTACT: "CONTACT";
+    readonly COMPANY: "COMPANY";
+    readonly COMPOSITE: "COMPOSITE";
+    readonly PERSON: "PERSON";
+    readonly ENRICHMENT: "ENRICHMENT";
+};
+export type IntegrationFieldType = keyof typeof IntegrationFieldTypeEnum;
+export type OAuthToken = OAuth2Token & {
+    [key: string]: any;
+};
+export type APIKey = {
+    apiKey: string;
+} & {
+    [key: string]: any;
+};
+export type CredentialValue = OAuthToken | APIKey;
+export type AuthToken = Omit<OAuthToken, 'refreshToken'> | APIKey;
+export type MakeWebhookURL = ({ event, name, }: {
+    name: string;
+    event: string;
+}) => string;
+export type EventHandlerExecutorParams = BaseContext<any>;
+export type EventHandlerReturnType = {
+    id: string;
+    event: string;
+    executor: ({ event, step }: EventHandlerExecutorParams) => Promise<any>;
+    onFailure?: ({ event, }: {
+        event: {
+            data: {
+                event: {
+                    data: Record<string, any>;
+                    user: Record<string, string>;
+                };
+            };
+        };
+    }) => Promise<any>;
+    cancelOn?: {
+        event: string;
+        if: string;
+    }[];
+};
+/**
+ * @param T - the type of the Integration Instance defining the event handler
+ */
+export type EventHandler<T = unknown> = (params: {
+    integrationInstance: T;
+    eventKey: string;
+    makeWebhookUrl: MakeWebhookURL;
+}) => EventHandlerReturnType;
+export type QueryResult<T> = {
+    data: T;
+};
+export type Routes = 'connect' | 'callback' | 'inngest' | 'webhook';
+export interface OpenAPI {
+    openapi: string;
+    info: OpenAPI_Info;
+    servers?: OpenAPI_Server[];
+    paths: OpenAPI_Paths;
+    components?: OpenAPI_Components;
+    security?: OpenAPI_SecurityRequirement[];
+    tags?: OpenAPI_Tag[];
+    externalDocs?: OpenAPI_ExternalDocumentation;
+}
+export interface OpenAPI_Info {
+    title: string;
+    version: string;
+    description?: string;
+    termsOfService?: string;
+    contact?: OpenAPI_Contact;
+    license?: OpenAPI_License;
+}
+export interface OpenAPI_Contact {
+    name?: string;
+    url?: string;
+    email?: string;
+}
+export interface OpenAPI_License {
+    name: string;
+    url?: string;
+}
+export interface OpenAPI_Server {
+    url: string;
+    description?: string;
+}
+export interface OpenAPI_Paths {
+    [path: string]: OpenAPI_PathItem;
+}
+export interface OpenAPI_PathItem {
+    summary?: string;
+    description?: string;
+    get?: OpenAPI_Operation;
+    put?: OpenAPI_Operation;
+    post?: OpenAPI_Operation;
+    delete?: OpenAPI_Operation;
+    options?: OpenAPI_Operation;
+    head?: OpenAPI_Operation;
+    patch?: OpenAPI_Operation;
+    trace?: OpenAPI_Operation;
+    servers?: OpenAPI_Server[];
+    parameters?: OpenAPI_Parameter[];
+}
+export interface OpenAPI_Operation {
+    summary?: string;
+    description?: string;
+    operationId?: string;
+    parameters?: OpenAPI_Parameter[];
+    requestBody?: OpenAPI_RequestBody;
+    responses: OpenAPI_Responses;
+    deprecated?: boolean;
+    security?: OpenAPI_SecurityRequirement[];
+    tags?: string[];
+    servers?: OpenAPI_Server[];
+}
+export interface OpenAPI_Parameter {
+    name: string;
+    in: 'query' | 'header' | 'path' | 'cookie';
+    description?: string;
+    required?: boolean;
+    schema: OpenAPI_Schema;
+    $ref?: string;
+    example?: string | string[];
+    enum?: string[];
+}
+export interface OpenAPI_RequestBody {
+    description?: string;
+    content: {
+        [mediaType: string]: OpenAPI_MediaType;
+    };
+    required?: boolean;
+}
+export interface OpenAPI_MediaType {
+    schema: OpenAPI_Schema;
+}
+export interface OpenAPI_Responses {
+    [statusCode: string]: OpenAPI_Response;
+}
+export interface OpenAPI_Response {
+    description: string;
+    content?: {
+        [mediaType: string]: OpenAPI_MediaType;
+    };
+    headers?: {
+        [headerName: string]: OpenAPI_Header;
+    };
+    links?: {
+        [linkName: string]: OpenAPI_Link;
+    };
+}
+export interface OpenAPI_Header {
+    description?: string;
+    schema: OpenAPI_Schema;
+}
+export interface OpenAPI_Link {
+    operationRef?: string;
+    operationId?: string;
+    parameters?: {
+        [parameterName: string]: any;
+    };
+    requestBody?: any;
+    description?: string;
+}
+export interface OpenAPI_Schema {
+    type?: string;
+    format?: string;
+    properties?: {
+        [propertyName: string]: OpenAPI_Schema;
+    };
+    required?: string[];
+    items?: OpenAPI_Schema;
+    enum?: any[];
+    example?: any;
+    $ref?: string;
+    allOf?: OpenAPI_Schema[];
+}
+export interface OpenAPI_Components {
+    schemas?: {
+        [schemaName: string]: OpenAPI_Schema;
+    };
+    responses?: {
+        [responseName: string]: OpenAPI_Response;
+    };
+    parameters?: {
+        [parameterName: string]: OpenAPI_Parameter;
+    };
+    requestBodies?: {
+        [requestBodyName: string]: OpenAPI_RequestBody;
+    };
+    headers?: {
+        [headerName: string]: OpenAPI_Header;
+    };
+    securitySchemes?: {
+        [securitySchemeName: string]: OpenAPI_SecurityScheme;
+    };
+    links?: {
+        [linkName: string]: OpenAPI_Link;
+    };
+    callbacks?: {
+        [callbackName: string]: OpenAPI_PathItem;
+    };
+}
+export interface OpenAPI_SecurityScheme {
+    type: 'apiKey' | 'http' | 'oauth2' | 'openIdConnect';
+    in?: 'query' | 'header' | 'cookie';
+    name?: string;
+    scheme?: string;
+    bearerFormat?: string;
+    flows?: OpenAPI_OAuthFlows;
+    openIdConnectUrl?: string;
+}
+export interface OpenAPI_OAuthFlows {
+    implicit?: OpenAPI_OAuthFlow;
+    password?: OpenAPI_OAuthFlow;
+    clientCredentials?: OpenAPI_OAuthFlow;
+    authorizationCode?: OpenAPI_OAuthFlow;
+}
+export interface OpenAPI_OAuthFlow {
+    authorizationUrl?: string;
+    tokenUrl?: string;
+    refreshUrl?: string;
+    scopes: {
+        [scope: string]: string;
+    };
+}
+export interface OpenAPI_SecurityRequirement {
+    [securitySchemeName: string]: string[];
+}
+export interface OpenAPI_Tag {
+    name: string;
+    description?: string;
+    externalDocs?: OpenAPI_ExternalDocumentation;
+}
+export interface OpenAPI_ExternalDocumentation {
+    description?: string;
+    url: string;
+}
+export interface OpenAPI_Callback {
+    [callbackName: string]: OpenAPI_PathItem;
+}
+export {};

package/dist/utils/errors.d.ts

@@ -0,0 +1,3 @@
+export declare class IntegrationError extends Error {
+    constructor(message: string);
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { SchemaFieldOptions } from '../types';
+/**
+ * Extract schema options for the provided schema - Builds a map of fieldname to field options
+ * @param schema - schema
+ * @param dataCtx - data context - this is an object of options for each field that isn't enum (meaning string fields) but should have options
+ * @returns schema options
+ * */
+export declare function extractSchemaOptions({ schema, dataCtx, }: {
+    schema: z.ZodObject<any>;
+    dataCtx?: Record<string, SchemaFieldOptions>;
+}): Record<string, SchemaFieldOptions>;

package/dist/utils/inngest.d.ts

@@ -0,0 +1,4 @@
+import { Inngest } from 'inngest';
+export declare const client: Inngest<{
+    id: string;
+}>;

package/dist/workflows/conditions/constants.d.ts

@@ -0,0 +1,16 @@
+export declare const FilterOpToValueMapEnum: {
+    readonly EQUAL: "EQUAL";
+    readonly NOT_EQUAL: "NOT_EQUAL";
+    readonly CONTAINS: "CONTAINS";
+    readonly IS: "IS";
+    readonly IS_NOT: "IS_NOT";
+    readonly NOT_CONTAINS: "NOT_CONTAINS";
+    readonly IS_ANY_OF: "IS_ANY_OF";
+    readonly GREATER_THAN: "GREATER_THAN";
+    readonly LESS_THAN: "LESS_THAN";
+    readonly DOES_NOT_CONTAIN: "DOES_NOT_CONTAIN";
+    readonly GREATER_THAN_OR_EQUAL: "GREATER_THAN_OR_EQUAL";
+    readonly LESS_THAN_OR_EQUAL: "LESS_THAN_OR_EQUAL";
+    readonly SET: "SET";
+    readonly NOT_SET: "NOT_SET";
+};

package/dist/workflows/conditions/types.d.ts

@@ -0,0 +1,2 @@
+import { FilterOpToValueMapEnum } from './constants';
+export type FilterOperator = keyof typeof FilterOpToValueMapEnum;

package/dist/workflows/handler.d.ts

@@ -0,0 +1,38 @@
+export declare const createWorkflowHandler: ({ blueprintDirPath, runBlueprint, }: {
+    blueprintDirPath: string;
+    runBlueprint: Function;
+}) => import("inngest").InngestFunction<Omit<import("inngest").InngestFunction.Options<import("inngest").Inngest<{
+    id: string;
+}>, import("inngest").InngestMiddleware.Stack, [{
+    event: string;
+}], import("inngest").Handler<import("inngest").Inngest<{
+    id: string;
+}>, string, {
+    event: import("inngest").FailureEventPayload<import("inngest").EventPayload<any>>;
+    logger: import("inngest/middleware/logger").Logger;
+    error: Error;
+}>>, "triggers">, ({ event, step }: import("inngest").Context<import("inngest").Inngest<{
+    id: string;
+}>, string, {
+    logger: import("inngest/middleware/logger").Logger;
+}>) => Promise<{
+    event: {
+        name: string;
+        ts?: number | undefined;
+        id?: string | undefined;
+        data?: any;
+        user?: any;
+        v?: string | undefined;
+    };
+    body: string;
+}>, import("inngest").Handler<import("inngest").Inngest<{
+    id: string;
+}>, string, {
+    event: import("inngest").FailureEventPayload<import("inngest").EventPayload<any>>;
+    logger: import("inngest/middleware/logger").Logger;
+    error: Error;
+}>, import("inngest").Inngest<{
+    id: string;
+}>, import("inngest").InngestMiddleware.Stack, [{
+    event: string;
+}]>;

package/dist/workflows/runner.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import { ActionVariables, Blueprint, WorkflowConditionGroup } from './types';
+import { IntegrationApi, IntegrationContext, IntegrationEvent } from '../types';
+export declare function evaluateCondition({ c, dataCtx, schema, triggerId, }: {
+    c: WorkflowConditionGroup;
+    dataCtx: any;
+    schema: z.ZodSchema<unknown>;
+    triggerId?: string;
+}): boolean;
+export declare function resolveSchemaPath({ currentPath, schema, targetPath, finalMap, }: {
+    currentPath: string;
+    schema: any;
+    targetPath: string;
+    finalMap: Record<string, any>;
+}): z.ZodSchema<unknown> | undefined;
+export declare function replacePayloadVariables({ value, stringContainingVariables, variable, }: {
+    value: string;
+    stringContainingVariables: string | string[];
+    variable: string;
+}): string | string[];
+export declare function resolveCondition({ c, dataCtx, schema, triggerId, }: {
+    c: WorkflowConditionGroup;
+    dataCtx: any;
+    triggerId?: string;
+    schema: z.ZodSchema<unknown>;
+}): boolean | undefined;
+export declare function resolvePath({ path, replacementDataPayload, }: {
+    path: string;
+    replacementDataPayload: any;
+}): any;
+export declare function resolvePayload({ payload, dataContext, variables, parentKey, }: {
+    payload: any;
+    dataContext: any;
+    variables?: Record<string, ActionVariables | undefined>;
+    parentKey?: string;
+}): Record<string, any>;
+export declare function blueprintRunner({ ctx, dataCtx, blueprint, frameworkEvents, frameworkApis, }: {
+    dataCtx: any;
+    ctx: IntegrationContext;
+    blueprint: Blueprint;
+    frameworkApis: Record<string, IntegrationApi<any>>;
+    frameworkEvents: Record<string, IntegrationEvent<any>>;
+}): Promise<void>;