@marktoflow/integrations 2.0.1 → 2.0.2

package/dist/services/google-sheets.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Google Sheets Integration
+ *
+ * Spreadsheet automation platform.
+ * API Docs: https://developers.google.com/sheets/api
+ */
+import { sheets_v4 } from 'googleapis';
+import { SDKInitializer } from '@marktoflow/core';
+export interface SpreadsheetInfo {
+    spreadsheetId: string;
+    properties: {
+        title: string;
+        locale: string;
+        autoRecalc: string;
+        timeZone: string;
+    };
+    sheets: SheetInfo[];
+}
+export interface SheetInfo {
+    sheetId: number;
+    title: string;
+    index: number;
+    sheetType: string;
+    gridProperties: {
+        rowCount: number;
+        columnCount: number;
+    };
+}
+export interface CellData {
+    row: number;
+    column: number;
+    value: string | number | boolean | null;
+    formattedValue?: string;
+    formula?: string;
+}
+export interface AppendValuesOptions {
+    range: string;
+    values: unknown[][];
+    valueInputOption?: 'RAW' | 'USER_ENTERED';
+    insertDataOption?: 'OVERWRITE' | 'INSERT_ROWS';
+}
+export interface UpdateValuesOptions {
+    range: string;
+    values: unknown[][];
+    valueInputOption?: 'RAW' | 'USER_ENTERED';
+}
+export interface BatchUpdateOptions {
+    data: {
+        range: string;
+        values: unknown[][];
+    }[];
+    valueInputOption?: 'RAW' | 'USER_ENTERED';
+}
+export interface CreateSpreadsheetOptions {
+    title: string;
+    sheets?: {
+        title: string;
+        rowCount?: number;
+        columnCount?: number;
+    }[];
+    locale?: string;
+    timeZone?: string;
+}
+export interface AddSheetOptions {
+    title: string;
+    rowCount?: number;
+    columnCount?: number;
+    index?: number;
+}
+/**
+ * Google Sheets actions for workflow integration
+ */
+export declare class GoogleSheetsActions {
+    private sheets;
+    constructor(sheets: sheets_v4.Sheets);
+    /**
+     * Get spreadsheet metadata
+     */
+    getSpreadsheet(spreadsheetId: string): Promise<SpreadsheetInfo>;
+    /**
+     * Get values from a range
+     */
+    getValues(spreadsheetId: string, range: string): Promise<unknown[][]>;
+    /**
+     * Get multiple ranges at once
+     */
+    batchGetValues(spreadsheetId: string, ranges: string[]): Promise<{
+        range: string;
+        values: unknown[][];
+    }[]>;
+    /**
+     * Append values to a sheet
+     */
+    appendValues(spreadsheetId: string, options: AppendValuesOptions): Promise<{
+        updatedRange: string;
+        updatedRows: number;
+        updatedColumns: number;
+    }>;
+    /**
+     * Update values in a range
+     */
+    updateValues(spreadsheetId: string, options: UpdateValuesOptions): Promise<{
+        updatedRange: string;
+        updatedRows: number;
+        updatedColumns: number;
+        updatedCells: number;
+    }>;
+    /**
+     * Update multiple ranges at once
+     */
+    batchUpdateValues(spreadsheetId: string, options: BatchUpdateOptions): Promise<{
+        totalUpdatedRows: number;
+        totalUpdatedColumns: number;
+        totalUpdatedCells: number;
+    }>;
+    /**
+     * Clear values in a range
+     */
+    clearValues(spreadsheetId: string, range: string): Promise<{
+        clearedRange: string;
+    }>;
+    /**
+     * Create a new spreadsheet
+     */
+    createSpreadsheet(options: CreateSpreadsheetOptions): Promise<SpreadsheetInfo>;
+    /**
+     * Add a new sheet to an existing spreadsheet
+     */
+    addSheet(spreadsheetId: string, options: AddSheetOptions): Promise<SheetInfo>;
+    /**
+     * Delete a sheet
+     */
+    deleteSheet(spreadsheetId: string, sheetId: number): Promise<void>;
+    /**
+     * Duplicate a sheet
+     */
+    duplicateSheet(spreadsheetId: string, sourceSheetId: number, newSheetName?: string): Promise<SheetInfo>;
+    /**
+     * Find and replace text
+     */
+    findReplace(spreadsheetId: string, find: string, replacement: string, options?: {
+        sheetId?: number;
+        allSheets?: boolean;
+        matchCase?: boolean;
+        matchEntireCell?: boolean;
+        searchByRegex?: boolean;
+    }): Promise<{
+        occurrencesChanged: number;
+        valuesChanged: number;
+    }>;
+    /**
+     * Sort a range
+     */
+    sortRange(spreadsheetId: string, range: string, sortSpecs: {
+        dimensionIndex: number;
+        sortOrder: 'ASCENDING' | 'DESCENDING';
+    }[]): Promise<void>;
+    /**
+     * Parse A1 notation into grid range
+     * Helper method for internal use
+     */
+    private parseA1Notation;
+}
+export declare const GoogleSheetsInitializer: SDKInitializer;
+//# sourceMappingURL=google-sheets.d.ts.map

package/dist/services/http.d.ts

@@ -0,0 +1,120 @@
+/**
+ * HTTP Integration
+ *
+ * Generic REST API client for calling any HTTP endpoint.
+ * Essential for APIs without dedicated integrations.
+ */
+import { SDKInitializer } from '@marktoflow/core';
+export interface HttpRequestOptions {
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+    headers?: Record<string, string>;
+    query?: Record<string, string | number | boolean>;
+    body?: unknown;
+    timeout?: number;
+    followRedirects?: boolean;
+    validateStatus?: (status: number) => boolean;
+}
+export interface HttpResponse<T = unknown> {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    data: T;
+    ok: boolean;
+    url: string;
+}
+export interface HttpClientConfig {
+    baseUrl?: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+    auth?: {
+        type: 'bearer' | 'basic' | 'api-key';
+        token?: string;
+        username?: string;
+        password?: string;
+        apiKey?: string;
+        apiKeyHeader?: string;
+    };
+}
+/**
+ * Generic HTTP client for workflow integration
+ */
+export declare class HttpClient {
+    private baseUrl;
+    private defaultHeaders;
+    private defaultTimeout;
+    constructor(config?: HttpClientConfig);
+    /**
+     * Make an HTTP request
+     */
+    request<T = unknown>(path: string, options?: HttpRequestOptions): Promise<HttpResponse<T>>;
+    /**
+     * GET request
+     */
+    get<T = unknown>(path: string, options?: Omit<HttpRequestOptions, 'method' | 'body'>): Promise<HttpResponse<T>>;
+    /**
+     * POST request
+     */
+    post<T = unknown>(path: string, body?: unknown, options?: Omit<HttpRequestOptions, 'method' | 'body'>): Promise<HttpResponse<T>>;
+    /**
+     * PUT request
+     */
+    put<T = unknown>(path: string, body?: unknown, options?: Omit<HttpRequestOptions, 'method' | 'body'>): Promise<HttpResponse<T>>;
+    /**
+     * PATCH request
+     */
+    patch<T = unknown>(path: string, body?: unknown, options?: Omit<HttpRequestOptions, 'method' | 'body'>): Promise<HttpResponse<T>>;
+    /**
+     * DELETE request
+     */
+    delete<T = unknown>(path: string, options?: Omit<HttpRequestOptions, 'method'>): Promise<HttpResponse<T>>;
+    /**
+     * HEAD request
+     */
+    head(path: string, options?: Omit<HttpRequestOptions, 'method' | 'body'>): Promise<HttpResponse<undefined>>;
+    /**
+     * Set a default header
+     */
+    setHeader(name: string, value: string): void;
+    /**
+     * Remove a default header
+     */
+    removeHeader(name: string): void;
+    /**
+     * Set bearer token
+     */
+    setBearerToken(token: string): void;
+    /**
+     * Set base URL
+     */
+    setBaseUrl(url: string): void;
+}
+/**
+ * HTTP error with response details
+ */
+export declare class HttpError extends Error {
+    readonly status: number;
+    readonly statusText: string;
+    readonly headers: Record<string, string>;
+    readonly data: unknown;
+    readonly url: string;
+    constructor(response: HttpResponse);
+}
+/**
+ * Convenience function to make a one-off request
+ */
+export declare function httpRequest<T = unknown>(url: string, options?: HttpRequestOptions & {
+    headers?: Record<string, string>;
+}): Promise<HttpResponse<T>>;
+/**
+ * GraphQL client helper
+ */
+export declare class GraphQLClient {
+    private http;
+    constructor(endpoint: string, config?: Omit<HttpClientConfig, 'baseUrl'>);
+    /**
+     * Execute a GraphQL query or mutation
+     */
+    query<T = unknown>(query: string, variables?: Record<string, unknown>, operationName?: string): Promise<T>;
+}
+export declare const HttpInitializer: SDKInitializer;
+//# sourceMappingURL=http.d.ts.map

package/dist/services/jira.d.ts

@@ -0,0 +1,3 @@
+import { SDKInitializer } from '@marktoflow/core';
+export declare const JiraInitializer: SDKInitializer;
+//# sourceMappingURL=jira.d.ts.map

package/dist/services/linear.d.ts

@@ -0,0 +1,163 @@
+/**
+ * Linear Integration
+ *
+ * Modern issue tracking for development teams.
+ * API Docs: https://developers.linear.app/docs/graphql/working-with-the-graphql-api
+ */
+import { SDKInitializer } from '@marktoflow/core';
+export interface LinearIssue {
+    id: string;
+    identifier: string;
+    title: string;
+    description?: string;
+    priority: number;
+    priorityLabel: string;
+    state: {
+        id: string;
+        name: string;
+        type: string;
+    };
+    assignee?: {
+        id: string;
+        name: string;
+        email: string;
+    };
+    team: {
+        id: string;
+        name: string;
+        key: string;
+    };
+    project?: {
+        id: string;
+        name: string;
+    };
+    labels: {
+        id: string;
+        name: string;
+        color: string;
+    }[];
+    createdAt: string;
+    updatedAt: string;
+    url: string;
+}
+export interface LinearProject {
+    id: string;
+    name: string;
+    description?: string;
+    state: string;
+    progress: number;
+    targetDate?: string;
+    teams: {
+        id: string;
+        name: string;
+    }[];
+}
+export interface LinearTeam {
+    id: string;
+    name: string;
+    key: string;
+    description?: string;
+    issueCount: number;
+}
+export interface CreateIssueOptions {
+    teamId: string;
+    title: string;
+    description?: string;
+    priority?: number;
+    assigneeId?: string;
+    labelIds?: string[];
+    projectId?: string;
+    stateId?: string;
+    estimate?: number;
+    dueDate?: string;
+    parentId?: string;
+}
+export interface UpdateIssueOptions {
+    title?: string;
+    description?: string;
+    priority?: number;
+    assigneeId?: string;
+    labelIds?: string[];
+    projectId?: string;
+    stateId?: string;
+    estimate?: number;
+    dueDate?: string;
+}
+export interface SearchIssuesOptions {
+    query?: string;
+    teamId?: string;
+    assigneeId?: string;
+    stateId?: string;
+    labelIds?: string[];
+    projectId?: string;
+    priority?: number;
+    first?: number;
+    after?: string;
+}
+/**
+ * Linear GraphQL client for workflow integration
+ */
+export declare class LinearClient {
+    private apiKey;
+    constructor(apiKey: string);
+    private query;
+    /**
+     * Get the current user
+     */
+    getViewer(): Promise<{
+        id: string;
+        name: string;
+        email: string;
+    }>;
+    /**
+     * List teams
+     */
+    listTeams(): Promise<LinearTeam[]>;
+    /**
+     * Get an issue by ID or identifier
+     */
+    getIssue(idOrIdentifier: string): Promise<LinearIssue>;
+    /**
+     * Create an issue
+     */
+    createIssue(options: CreateIssueOptions): Promise<LinearIssue>;
+    /**
+     * Update an issue
+     */
+    updateIssue(issueId: string, options: UpdateIssueOptions): Promise<LinearIssue>;
+    /**
+     * Search issues
+     */
+    searchIssues(options?: SearchIssuesOptions): Promise<{
+        issues: LinearIssue[];
+        hasMore: boolean;
+        endCursor?: string;
+    }>;
+    /**
+     * List projects
+     */
+    listProjects(teamId?: string): Promise<LinearProject[]>;
+    /**
+     * Get workflow states for a team
+     */
+    getWorkflowStates(teamId: string): Promise<{
+        id: string;
+        name: string;
+        type: string;
+        position: number;
+    }[]>;
+    /**
+     * Add a comment to an issue
+     */
+    addComment(issueId: string, body: string): Promise<{
+        id: string;
+        body: string;
+        createdAt: string;
+    }>;
+    /**
+     * Archive an issue
+     */
+    archiveIssue(issueId: string): Promise<void>;
+}
+export declare const LinearInitializer: SDKInitializer;
+//# sourceMappingURL=linear.d.ts.map

package/dist/services/mysql.d.ts

@@ -0,0 +1,91 @@
+/**
+ * MySQL Integration
+ *
+ * Popular open-source relational database.
+ * API: Using mysql2 driver
+ */
+import { SDKInitializer } from '@marktoflow/core';
+export interface MySQLConfig {
+    host: string;
+    port?: number;
+    database: string;
+    user: string;
+    password: string;
+    ssl?: boolean | {
+        rejectUnauthorized?: boolean;
+    };
+    connectTimeout?: number;
+    connectionLimit?: number;
+    waitForConnections?: boolean;
+    queueLimit?: number;
+}
+export interface QueryResult<T = unknown> {
+    rows: T[];
+    fields: {
+        name: string;
+        type: string;
+    }[];
+    affectedRows?: number;
+    insertId?: number;
+}
+export interface MySQLTransaction {
+    query<T = unknown>(sql: string, params?: unknown[]): Promise<QueryResult<T>>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+}
+/**
+ * MySQL client wrapper for workflow integration
+ * Note: This is a lightweight wrapper. The actual mysql2 module will be dynamically imported.
+ */
+export declare class MySQLClient {
+    private pool;
+    private config;
+    constructor(config: MySQLConfig);
+    /**
+     * Initialize the connection pool
+     */
+    connect(): Promise<void>;
+    /**
+     * Execute a SQL query
+     */
+    query<T = unknown>(sql: string, params?: unknown[]): Promise<QueryResult<T>>;
+    /**
+     * Select data from a table
+     */
+    select<T = Record<string, unknown>>(table: string, options?: {
+        columns?: string[];
+        where?: Record<string, unknown>;
+        orderBy?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<T[]>;
+    /**
+     * Insert data into a table
+     */
+    insert<T = Record<string, unknown>>(table: string, data: Record<string, unknown> | Record<string, unknown>[]): Promise<{
+        insertId: number;
+        affectedRows: number;
+    }>;
+    /**
+     * Update data in a table
+     */
+    update<T = Record<string, unknown>>(table: string, data: Record<string, unknown>, where: Record<string, unknown>): Promise<{
+        affectedRows: number;
+    }>;
+    /**
+     * Delete data from a table
+     */
+    delete<T = Record<string, unknown>>(table: string, where: Record<string, unknown>): Promise<{
+        affectedRows: number;
+    }>;
+    /**
+     * Begin a transaction
+     */
+    transaction<T>(callback: (trx: MySQLTransaction) => Promise<T>): Promise<T>;
+    /**
+     * Close the connection pool
+     */
+    close(): Promise<void>;
+}
+export declare const MySQLInitializer: SDKInitializer;
+//# sourceMappingURL=mysql.d.ts.map

package/dist/services/outlook-trigger.d.ts

@@ -0,0 +1,121 @@
+import { TriggerType } from '@marktoflow/core';
+export interface OutlookTriggerConfig {
+    token: string;
+    notificationUrl: string;
+    changeTypes?: ('created' | 'updated' | 'deleted')[];
+    resource?: string;
+    expirationMinutes?: number;
+    clientState?: string;
+    triggers: Array<{
+        id: string;
+        event: 'email_received' | 'email_updated' | 'email_deleted';
+        handler: (payload: OutlookTriggerPayload) => Promise<void>;
+    }>;
+}
+export interface OutlookTriggerPayload {
+    type: TriggerType;
+    event: 'email_received' | 'email_updated' | 'email_deleted';
+    subscriptionId: string;
+    changeType: string;
+    resource: string;
+    resourceData?: {
+        id: string;
+        [key: string]: unknown;
+    };
+    clientState?: string;
+    tenantId?: string;
+}
+export interface GraphSubscription {
+    id: string;
+    resource: string;
+    changeType: string;
+    notificationUrl: string;
+    expirationDateTime: string;
+    clientState?: string;
+}
+export interface GraphNotification {
+    value: Array<{
+        subscriptionId: string;
+        subscriptionExpirationDateTime: string;
+        changeType: string;
+        resource: string;
+        resourceData?: {
+            '@odata.type': string;
+            '@odata.id': string;
+            '@odata.etag': string;
+            id: string;
+            [key: string]: unknown;
+        };
+        clientState?: string;
+        tenantId?: string;
+    }>;
+}
+export interface GraphValidationRequest extends Record<string, unknown> {
+    validationToken: string;
+}
+/**
+ * Outlook trigger handler for Microsoft Graph webhook subscriptions.
+ *
+ * Setup requirements:
+ * 1. Register an Azure AD application with Mail.Read permissions
+ * 2. Set up a publicly accessible webhook endpoint
+ * 3. Call subscribe() to start receiving notifications
+ * 4. Handle subscription renewal before expiration (max ~3 days)
+ */
+export declare class OutlookTrigger {
+    private config;
+    private client;
+    private subscription?;
+    constructor(config: OutlookTriggerConfig);
+    /**
+     * Create a subscription to receive mail notifications.
+     */
+    subscribe(): Promise<GraphSubscription>;
+    /**
+     * Renew an existing subscription.
+     */
+    renew(expirationMinutes?: number): Promise<GraphSubscription>;
+    /**
+     * Delete the subscription (stop receiving notifications).
+     */
+    unsubscribe(): Promise<void>;
+    /**
+     * Get the current subscription status.
+     */
+    getSubscription(): GraphSubscription | undefined;
+    /**
+     * Check if subscription is still active (not expired).
+     */
+    isSubscriptionActive(): boolean;
+    /**
+     * Handle an incoming Graph notification.
+     * Call this from your webhook endpoint after validation.
+     */
+    handleNotification(notification: GraphNotification): Promise<void>;
+    /**
+     * Check if a request is a validation request from Graph.
+     */
+    static isValidationRequest(query: Record<string, unknown>): query is GraphValidationRequest;
+    /**
+     * Validate the notification body structure.
+     */
+    static validateNotification(body: unknown): body is GraphNotification;
+}
+/**
+ * Express/Fastify-compatible middleware for handling Outlook Graph webhooks.
+ *
+ * Handles both:
+ * - Subscription validation (GET with validationToken)
+ * - Notification processing (POST with notification payload)
+ */
+export declare function createOutlookWebhookHandler(trigger: OutlookTrigger): (req: {
+    method: string;
+    query: Record<string, unknown>;
+    body: unknown;
+}, res: {
+    status: (code: number) => {
+        send: (body?: string) => void;
+    };
+    contentType: (type: string) => void;
+}) => Promise<void>;
+//# sourceMappingURL=outlook-trigger.d.ts.map