digital-tools 2.0.2 → 2.1.3

package/src/providers/forms/typeform.js

@@ -0,0 +1,500 @@
+/**
+ * Typeform Forms Provider
+ *
+ * Concrete implementation of FormsProvider using Typeform API.
+ *
+ * @packageDocumentation
+ */
+import { defineProvider } from '../registry.js';
+const TYPEFORM_API_URL = 'https://api.typeform.com';
+/**
+ * Typeform provider info
+ */
+export const typeformInfo = {
+    id: 'forms.typeform',
+    name: 'Typeform',
+    description: 'Beautiful, user-friendly online forms and surveys',
+    category: 'forms',
+    website: 'https://typeform.com',
+    docsUrl: 'https://developer.typeform.com',
+    requiredConfig: ['accessToken'],
+    optionalConfig: ['workspaceId'],
+};
+/**
+ * Create Typeform forms provider
+ */
+export function createTypeformProvider(config) {
+    let accessToken;
+    let workspaceId;
+    return {
+        info: typeformInfo,
+        async initialize(cfg) {
+            accessToken = cfg.accessToken;
+            workspaceId = cfg.workspaceId;
+            if (!accessToken) {
+                throw new Error('Typeform access token is required');
+            }
+        },
+        async healthCheck() {
+            const start = Date.now();
+            try {
+                const response = await fetch(`${TYPEFORM_API_URL}/me`, {
+                    headers: {
+                        Authorization: `Bearer ${accessToken}`,
+                    },
+                });
+                return {
+                    healthy: response.ok,
+                    latencyMs: Date.now() - start,
+                    message: response.ok ? 'Connected' : `HTTP ${response.status}`,
+                    checkedAt: new Date(),
+                };
+            }
+            catch (error) {
+                return {
+                    healthy: false,
+                    latencyMs: Date.now() - start,
+                    message: error instanceof Error ? error.message : 'Unknown error',
+                    checkedAt: new Date(),
+                };
+            }
+        },
+        async dispose() {
+            // No cleanup needed
+        },
+        async createForm(form) {
+            const body = {
+                title: form.title,
+                type: 'form',
+            };
+            if (workspaceId) {
+                body.workspace = { href: `${TYPEFORM_API_URL}/workspaces/${workspaceId}` };
+            }
+            // Map fields to Typeform format
+            if (form.fields && form.fields.length > 0) {
+                body.fields = form.fields.map((field, index) => {
+                    const typeformField = {
+                        title: field.title,
+                        ref: `field_${index}`,
+                        properties: {},
+                    };
+                    // Map field types
+                    switch (field.type) {
+                        case 'text':
+                            typeformField.type = 'short_text';
+                            break;
+                        case 'textarea':
+                            typeformField.type = 'long_text';
+                            break;
+                        case 'email':
+                            typeformField.type = 'email';
+                            break;
+                        case 'number':
+                            typeformField.type = 'number';
+                            break;
+                        case 'date':
+                            typeformField.type = 'date';
+                            break;
+                        case 'dropdown':
+                            typeformField.type = 'dropdown';
+                            if (field.choices) {
+                                typeformField.properties = {
+                                    choices: field.choices.map((choice) => ({ label: choice })),
+                                };
+                            }
+                            break;
+                        case 'radio':
+                            typeformField.type = 'multiple_choice';
+                            if (field.choices) {
+                                typeformField.properties = {
+                                    choices: field.choices.map((choice) => ({ label: choice })),
+                                    allow_multiple_selection: false,
+                                };
+                            }
+                            break;
+                        case 'checkbox':
+                            typeformField.type = 'multiple_choice';
+                            if (field.choices) {
+                                typeformField.properties = {
+                                    choices: field.choices.map((choice) => ({ label: choice })),
+                                    allow_multiple_selection: true,
+                                };
+                            }
+                            break;
+                        case 'file':
+                            typeformField.type = 'file_upload';
+                            break;
+                        default:
+                            typeformField.type = 'short_text';
+                    }
+                    if (field.description) {
+                        typeformField.properties = {
+                            ...(typeof typeformField.properties === 'object' ? typeformField.properties : {}),
+                            description: field.description,
+                        };
+                    }
+                    typeformField.validations = {
+                        required: field.required || false,
+                    };
+                    return typeformField;
+                });
+            }
+            // Add settings
+            if (form.settings) {
+                body.settings = {
+                    is_public: form.settings.isPublic !== undefined ? form.settings.isPublic : true,
+                    show_progress_bar: form.settings.showProgressBar || false,
+                };
+                if (form.settings.confirmationMessage) {
+                    body.thankyou_screens = [
+                        {
+                            title: 'Thank you!',
+                            properties: {
+                                show_button: false,
+                                share_icons: false,
+                            },
+                        },
+                    ];
+                }
+                if (form.settings.redirectUrl) {
+                    body.thankyou_screens = [
+                        {
+                            title: 'Thank you!',
+                            properties: {
+                                show_button: true,
+                                button_text: 'Continue',
+                                button_mode: 'redirect',
+                                redirect_url: form.settings.redirectUrl,
+                            },
+                        },
+                    ];
+                }
+            }
+            try {
+                const response = await fetch(`${TYPEFORM_API_URL}/forms`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: `Bearer ${accessToken}`,
+                    },
+                    body: JSON.stringify(body),
+                });
+                if (!response.ok) {
+                    const errorData = await response.json().catch(() => ({}));
+                    throw new Error(`Failed to create form: ${errorData?.message || response.statusText}`);
+                }
+                const data = await response.json();
+                return transformTypeformToFormData(data);
+            }
+            catch (error) {
+                throw new Error(`Failed to create form: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        },
+        async getForm(formId) {
+            try {
+                const response = await fetch(`${TYPEFORM_API_URL}/forms/${formId}`, {
+                    headers: {
+                        Authorization: `Bearer ${accessToken}`,
+                    },
+                });
+                if (response.status === 404) {
+                    return null;
+                }
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}`);
+                }
+                const data = await response.json();
+                return transformTypeformToFormData(data);
+            }
+            catch (error) {
+                throw new Error(`Failed to get form: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        },
+        async updateForm(formId, updates) {
+            const body = {};
+            if (updates.title) {
+                body.title = updates.title;
+            }
+            if (updates.fields) {
+                body.fields = updates.fields.map((field, index) => {
+                    const typeformField = {
+                        title: field.title,
+                        ref: `field_${index}`,
+                        properties: {},
+                    };
+                    // Map field types (same as createForm)
+                    switch (field.type) {
+                        case 'text':
+                            typeformField.type = 'short_text';
+                            break;
+                        case 'textarea':
+                            typeformField.type = 'long_text';
+                            break;
+                        case 'email':
+                            typeformField.type = 'email';
+                            break;
+                        case 'number':
+                            typeformField.type = 'number';
+                            break;
+                        case 'date':
+                            typeformField.type = 'date';
+                            break;
+                        case 'dropdown':
+                            typeformField.type = 'dropdown';
+                            if (field.choices) {
+                                typeformField.properties = {
+                                    choices: field.choices.map((choice) => ({ label: choice })),
+                                };
+                            }
+                            break;
+                        case 'radio':
+                            typeformField.type = 'multiple_choice';
+                            if (field.choices) {
+                                typeformField.properties = {
+                                    choices: field.choices.map((choice) => ({ label: choice })),
+                                    allow_multiple_selection: false,
+                                };
+                            }
+                            break;
+                        case 'checkbox':
+                            typeformField.type = 'multiple_choice';
+                            if (field.choices) {
+                                typeformField.properties = {
+                                    choices: field.choices.map((choice) => ({ label: choice })),
+                                    allow_multiple_selection: true,
+                                };
+                            }
+                            break;
+                        case 'file':
+                            typeformField.type = 'file_upload';
+                            break;
+                        default:
+                            typeformField.type = 'short_text';
+                    }
+                    if (field.description) {
+                        typeformField.properties = {
+                            ...(typeof typeformField.properties === 'object' ? typeformField.properties : {}),
+                            description: field.description,
+                        };
+                    }
+                    typeformField.validations = {
+                        required: field.required || false,
+                    };
+                    return typeformField;
+                });
+            }
+            if (updates.settings) {
+                body.settings = {
+                    ...(updates.settings.isPublic !== undefined && {
+                        is_public: updates.settings.isPublic,
+                    }),
+                    ...(updates.settings.showProgressBar !== undefined && {
+                        show_progress_bar: updates.settings.showProgressBar,
+                    }),
+                };
+            }
+            try {
+                const response = await fetch(`${TYPEFORM_API_URL}/forms/${formId}`, {
+                    method: 'PATCH',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: `Bearer ${accessToken}`,
+                    },
+                    body: JSON.stringify(body),
+                });
+                if (!response.ok) {
+                    const errorData = await response.json().catch(() => ({}));
+                    throw new Error(`Failed to update form: ${errorData?.message || response.statusText}`);
+                }
+                const data = await response.json();
+                return transformTypeformToFormData(data);
+            }
+            catch (error) {
+                throw new Error(`Failed to update form: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        },
+        async deleteForm(formId) {
+            try {
+                const response = await fetch(`${TYPEFORM_API_URL}/forms/${formId}`, {
+                    method: 'DELETE',
+                    headers: {
+                        Authorization: `Bearer ${accessToken}`,
+                    },
+                });
+                return response.ok || response.status === 204;
+            }
+            catch (error) {
+                throw new Error(`Failed to delete form: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        },
+        async listForms(options) {
+            const params = new URLSearchParams();
+            const pageSize = options?.limit || 10;
+            const page = options?.offset ? Math.floor(options.offset / pageSize) + 1 : 1;
+            params.set('page_size', pageSize.toString());
+            params.set('page', page.toString());
+            if (workspaceId) {
+                params.set('workspace_id', workspaceId);
+            }
+            try {
+                const response = await fetch(`${TYPEFORM_API_URL}/forms?${params}`, {
+                    headers: {
+                        Authorization: `Bearer ${accessToken}`,
+                    },
+                });
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}`);
+                }
+                const data = (await response.json());
+                const items = (data.items || []).map(transformTypeformToFormData);
+                return {
+                    items,
+                    total: data.total_items,
+                    hasMore: data.page_count > page,
+                    nextCursor: data.page_count > page ? ((page + 1) * pageSize).toString() : undefined,
+                };
+            }
+            catch (error) {
+                throw new Error(`Failed to list forms: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        },
+        async getResponses(formId, options) {
+            const params = new URLSearchParams();
+            const pageSize = options?.limit || 25;
+            params.set('page_size', pageSize.toString());
+            if (options?.since) {
+                params.set('since', options.since.toISOString());
+            }
+            if (options?.until) {
+                params.set('until', options.until.toISOString());
+            }
+            if (options?.completed !== undefined) {
+                params.set('completed', options.completed.toString());
+            }
+            if (options?.cursor) {
+                params.set('before', options.cursor);
+            }
+            try {
+                const response = await fetch(`${TYPEFORM_API_URL}/forms/${formId}/responses?${params}`, {
+                    headers: {
+                        Authorization: `Bearer ${accessToken}`,
+                    },
+                });
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}`);
+                }
+                const data = (await response.json());
+                const items = (data.items || []).map((item) => transformTypeformResponseToFormResponseData(formId, item));
+                return {
+                    items,
+                    total: data.total_items,
+                    hasMore: !!data.next_cursor,
+                    nextCursor: data.next_cursor,
+                };
+            }
+            catch (error) {
+                throw new Error(`Failed to get responses: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        },
+        async getResponse(formId, responseId) {
+            try {
+                const response = await fetch(`${TYPEFORM_API_URL}/forms/${formId}/responses`, {
+                    headers: {
+                        Authorization: `Bearer ${accessToken}`,
+                    },
+                });
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}`);
+                }
+                const data = (await response.json());
+                const item = data.items?.find((r) => r.response_id === responseId);
+                if (!item) {
+                    return null;
+                }
+                return transformTypeformResponseToFormResponseData(formId, item);
+            }
+            catch (error) {
+                throw new Error(`Failed to get response: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        },
+    };
+}
+/**
+ * Transform Typeform API response to FormData
+ */
+function transformTypeformToFormData(data) {
+    // Map Typeform fields back to our format
+    const fields = (data.fields || []).map((field) => {
+        let type = 'text';
+        // Map Typeform types back to our types
+        switch (field.type) {
+            case 'short_text':
+                type = 'text';
+                break;
+            case 'long_text':
+                type = 'textarea';
+                break;
+            case 'email':
+                type = 'email';
+                break;
+            case 'number':
+                type = 'number';
+                break;
+            case 'date':
+                type = 'date';
+                break;
+            case 'dropdown':
+                type = 'dropdown';
+                break;
+            case 'multiple_choice':
+                type = field.properties?.allow_multiple_selection ? 'checkbox' : 'radio';
+                break;
+            case 'file_upload':
+                type = 'file';
+                break;
+        }
+        return {
+            type,
+            title: field.title,
+            description: field.properties?.description,
+            required: field.validations?.required || false,
+            choices: field.properties?.choices?.map((c) => c.label),
+        };
+    });
+    return {
+        id: data.id,
+        title: data.title,
+        description: data.description,
+        fields,
+        responseCount: data.response_count || 0,
+        url: data._links?.display || `https://form.typeform.com/to/${data.id}`,
+        createdAt: new Date(data.created_at),
+        updatedAt: new Date(data.last_updated_at || data.created_at),
+    };
+}
+/**
+ * Transform Typeform response to FormResponseData
+ */
+function transformTypeformResponseToFormResponseData(formId, data) {
+    const answers = (data.answers || []).map((answer) => ({
+        fieldId: answer.field.ref || answer.field.id,
+        value: answer[answer.type] || answer.text || answer.choice || answer.choices,
+    }));
+    return {
+        id: data.response_id || data.token,
+        formId,
+        answers,
+        submittedAt: new Date(data.submitted_at),
+        metadata: data.metadata
+            ? {
+                ip: data.metadata.user_agent,
+                userAgent: data.metadata.user_agent,
+                referer: data.metadata.referer,
+            }
+            : undefined,
+    };
+}
+/**
+ * Typeform provider definition
+ */
+export const typeformProvider = defineProvider(typeformInfo, async (config) => createTypeformProvider(config));

package/src/providers/index.js

@@ -0,0 +1,123 @@
+/**
+ * Digital Tool Providers
+ *
+ * Concrete implementations of entity types using third-party APIs.
+ *
+ * @packageDocumentation
+ */
+// Provider types and registry
+export * from './types.js';
+export { providerRegistry, createProviderRegistry, registerProvider, getProvider, createProvider, listProviders, defineProvider, } from './registry.js';
+// Email providers
+export { sendgridInfo, sendgridProvider, createSendGridProvider, resendInfo, resendProvider, createResendProvider, registerEmailProviders, emailProviders, } from './email/index.js';
+// Messaging providers
+export { slackInfo, slackProvider, createSlackProvider, twilioSmsInfo, twilioSmsProvider, createTwilioSmsProvider, registerMessagingProviders, messagingProviders, } from './messaging/index.js';
+// Spreadsheet providers
+export { xlsxInfo, xlsxProvider, createXlsxProvider, googleSheetsInfo, googleSheetsProvider, createGoogleSheetsProvider, registerSpreadsheetProviders, spreadsheetProviders, } from './spreadsheet/index.js';
+// Media providers
+export { cloudinaryInfo, cloudinaryProvider, createCloudinaryProvider, registerMediaProviders, mediaProviders, } from './media/index.js';
+// Task providers
+export { todoistInfo, todoistProvider, createTodoistProvider, registerTaskProviders, taskProviders, } from './tasks/index.js';
+// Finance providers
+export { stripeInfo, stripeProvider, createStripeProvider, registerFinanceProviders, financeProviders, } from './finance/index.js';
+// Support providers
+export { zendeskInfo, zendeskProvider, createZendeskProvider, registerSupportProviders, supportProviders, } from './support/index.js';
+// Project management providers
+export { linearInfo, linearProvider, createLinearProvider, registerProjectManagementProviders, projectManagementProviders, } from './project-management/index.js';
+// Knowledge providers
+export { notionInfo, notionProvider, createNotionProvider, registerKnowledgeProviders, knowledgeProviders, } from './knowledge/index.js';
+// CRM providers
+export { hubspotInfo, hubspotProvider, createHubSpotProvider, registerCRMProviders, crmProviders, } from './crm/index.js';
+// E-commerce providers
+export { shopifyInfo, shopifyProvider, createShopifyProvider, registerEcommerceProviders, ecommerceProviders, } from './ecommerce/index.js';
+// Development providers
+export { githubInfo, githubProvider, createGitHubProvider, registerDevelopmentProviders, developmentProviders, } from './development/index.js';
+// Forms providers
+export { typeformInfo, typeformProvider, createTypeformProvider, registerFormsProviders, formsProviders, } from './forms/index.js';
+// Analytics providers
+export { mixpanelInfo, mixpanelProvider, createMixpanelProvider, registerAnalyticsProviders, analyticsProviders, } from './analytics/index.js';
+// Video conferencing providers
+export { zoomInfo, zoomProvider, createZoomProvider, googleMeetInfo, googleMeetProvider, createGoogleMeetProvider, teamsInfo, teamsProvider, createTeamsProvider, jitsiInfo, jitsiProvider, createJitsiProvider, registerVideoConferencingProviders, videoConferencingProviders, } from './video-conferencing/index.js';
+// Calendar providers
+export { googleCalendarInfo, googleCalendarProvider, createGoogleCalendarProvider, registerCalendarProviders, calendarProviders, } from './calendar/index.js';
+// Storage providers
+export { s3Info, s3Provider, createS3Provider, registerStorageProviders, storageProviders, } from './storage/index.js';
+// Import for registration
+import { registerEmailProviders } from './email/index.js';
+import { registerMessagingProviders } from './messaging/index.js';
+import { registerSpreadsheetProviders } from './spreadsheet/index.js';
+import { registerMediaProviders } from './media/index.js';
+import { registerTaskProviders } from './tasks/index.js';
+import { registerFinanceProviders } from './finance/index.js';
+import { registerKnowledgeProviders } from './knowledge/index.js';
+import { registerCRMProviders } from './crm/index.js';
+import { registerSupportProviders } from './support/index.js';
+import { registerProjectManagementProviders } from './project-management/index.js';
+import { registerEcommerceProviders } from './ecommerce/index.js';
+import { registerDevelopmentProviders } from './development/index.js';
+import { registerFormsProviders } from './forms/index.js';
+import { registerAnalyticsProviders } from './analytics/index.js';
+import { registerVideoConferencingProviders } from './video-conferencing/index.js';
+import { registerCalendarProviders } from './calendar/index.js';
+import { registerStorageProviders } from './storage/index.js';
+/**
+ * Register all built-in providers in the global registry
+ */
+export function registerAllProviders() {
+    registerEmailProviders();
+    registerMessagingProviders();
+    registerSpreadsheetProviders();
+    registerMediaProviders();
+    registerTaskProviders();
+    registerFinanceProviders();
+    registerKnowledgeProviders();
+    registerSupportProviders();
+    registerProjectManagementProviders();
+    registerCRMProviders();
+    registerEcommerceProviders();
+    registerDevelopmentProviders();
+    registerFormsProviders();
+    registerAnalyticsProviders();
+    registerVideoConferencingProviders();
+    registerCalendarProviders();
+    registerStorageProviders();
+}
+/**
+ * All providers by category (single-word identifiers)
+ */
+export const allProviders = {
+    // Message category (email, messaging)
+    email: ['email.sendgrid', 'email.resend'],
+    messaging: ['messaging.slack', 'messaging.twilio-sms'],
+    // Productivity
+    calendar: ['calendar.google-calendar', 'calendar.cal-com'],
+    task: ['task.todoist'],
+    // Project management & Code
+    project: ['project.linear'],
+    code: ['code.github'],
+    // Business
+    sales: ['sales.hubspot'],
+    finance: ['finance.stripe'],
+    support: ['support.zendesk'],
+    commerce: ['commerce.shopify'],
+    // Content
+    knowledge: ['knowledge.notion'],
+    media: ['media.cloudinary'],
+    form: ['form.typeform'],
+    analytics: ['analytics.mixpanel'],
+    // Office suite
+    document: [], // TODO: Google Docs, Office365, Markdown providers
+    spreadsheet: ['spreadsheet.xlsx', 'spreadsheet.google-sheets'],
+    presentation: [], // TODO: Google Slides, PowerPoint providers
+    // Communication
+    meeting: [
+        'meeting.zoom',
+        'meeting.google-meet',
+        'meeting.teams',
+        'meeting.jitsi',
+    ],
+    // Infrastructure
+    storage: ['storage.s3'],
+    // Signature (e-sign)
+    signature: [], // TODO: DocuSign, DocuSeal providers
+};

package/src/providers/knowledge/index.js

@@ -0,0 +1,17 @@
+/**
+ * Knowledge Providers
+ *
+ * @packageDocumentation
+ */
+export { notionInfo, notionProvider, createNotionProvider } from './notion.js';
+import { notionProvider } from './notion.js';
+/**
+ * Register all knowledge providers
+ */
+export function registerKnowledgeProviders() {
+    notionProvider.register();
+}
+/**
+ * All knowledge providers
+ */
+export const knowledgeProviders = [notionProvider];