digital-tools 2.1.1 → 2.3.0

package/src/providers/forms/typeform.js

@@ -1,500 +0,0 @@
-/**
- * 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

@@ -1,123 +0,0 @@
-/**
- * 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

@@ -1,17 +0,0 @@
-/**
- * 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];