@retab/node 0.0.46 → 0.0.52

package/dist/utils/webhook_secrets.js

@@ -1,107 +0,0 @@
-import { createHash, createHmac, timingSafeEqual } from 'crypto';
-/**
- * Generate webhook signature for payload
- */
-export function generateSignature(payload, secret, timestamp, encoding = 'hex') {
-    const ts = timestamp || Math.floor(Date.now() / 1000);
-    const payloadString = Buffer.isBuffer(payload) ? payload.toString('utf8') : payload;
-    const signedPayload = `${ts}.${payloadString}`;
-    const hmac = createHmac('sha256', secret);
-    hmac.update(signedPayload);
-    return hmac.digest(encoding);
-}
-/**
- * Verify webhook signature
- */
-export function verifySignature(payload, signature, secret, timestamp, config = {}) {
-    const { tolerance = 300, encoding = 'hex' } = config; // 5 minute default tolerance
-    try {
-        const ts = timestamp || Math.floor(Date.now() / 1000);
-        const expectedSignature = generateSignature(payload, secret, ts, encoding);
-        // Use timing-safe comparison to prevent timing attacks
-        const sigBuffer = Buffer.from(signature, encoding);
-        const expectedBuffer = Buffer.from(expectedSignature, encoding);
-        if (sigBuffer.length !== expectedBuffer.length) {
-            return false;
-        }
-        const isSignatureValid = timingSafeEqual(sigBuffer, expectedBuffer);
-        // Check timestamp tolerance if provided
-        if (timestamp && tolerance > 0) {
-            const now = Math.floor(Date.now() / 1000);
-            const isTimestampValid = Math.abs(now - timestamp) <= tolerance;
-            return isSignatureValid && isTimestampValid;
-        }
-        return isSignatureValid;
-    }
-    catch (error) {
-        return false;
-    }
-}
-/**
- * Parse webhook headers for signature and timestamp
- */
-export function parseWebhookHeaders(headers) {
-    const signature = headers['x-webhook-signature'] ||
-        headers['x-retab-signature'] ||
-        headers['signature'];
-    const timestampHeader = headers['x-webhook-timestamp'] ||
-        headers['x-retab-timestamp'] ||
-        headers['timestamp'];
-    const timestamp = timestampHeader ? parseInt(timestampHeader, 10) : undefined;
-    return { signature, timestamp };
-}
-/**
- * Verify webhook request
- */
-export function verifyWebhookRequest(payload, headers, secret, config = {}) {
-    const { signature, timestamp } = parseWebhookHeaders(headers);
-    if (!signature) {
-        return false;
-    }
-    return verifySignature(payload, signature, secret, timestamp, config);
-}
-/**
- * Generate webhook secret
- */
-export function generateWebhookSecret(length = 32) {
-    return createHash('sha256')
-        .update(Math.random().toString())
-        .update(Date.now().toString())
-        .digest('hex')
-        .slice(0, length);
-}
-/**
- * Create webhook signature header
- */
-export function createSignatureHeader(payload, secret, encoding = 'hex') {
-    const timestamp = Math.floor(Date.now() / 1000);
-    const signature = generateSignature(payload, secret, timestamp, encoding);
-    return { signature, timestamp };
-}
-/**
- * Webhook middleware for Express-like frameworks
- */
-export function webhookMiddleware(secret, config = {}) {
-    return (req, res, next) => {
-        try {
-            const payload = req.rawBody || req.body;
-            const headers = req.headers;
-            if (!verifyWebhookRequest(payload, headers, secret, config)) {
-                return res.status(401).json({ error: 'Invalid webhook signature' });
-            }
-            next();
-        }
-        catch (error) {
-            return res.status(400).json({ error: 'Webhook verification failed' });
-        }
-    };
-}
-export default {
-    generateSignature,
-    verifySignature,
-    parseWebhookHeaders,
-    verifyWebhookRequest,
-    generateWebhookSecret,
-    createSignatureHeader,
-    webhookMiddleware,
-};

package/dist/utils/zod_to_json_schema.d.ts

@@ -1,11 +0,0 @@
-import { z } from 'zod';
-/**
- * Convert a Zod schema to JSON Schema.
- * This is a basic implementation that handles common Zod types.
- */
-export declare function zodToJsonSchema(zodSchema: z.ZodType<any>): Record<string, any>;
-/**
- * Extract descriptions from Zod schema and convert them to field descriptions.
- */
-export declare function extractZodDescriptions(zodSchema: z.ZodType<any>): Record<string, string>;
-//# sourceMappingURL=zod_to_json_schema.d.ts.map

package/dist/utils/zod_to_json_schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"zod_to_json_schema.d.ts","sourceRoot":"","sources":["../../src/utils/zod_to_json_schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CA8G9E;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA0BxF"}

package/dist/utils/zod_to_json_schema.js

@@ -1,123 +0,0 @@
-/**
- * Convert a Zod schema to JSON Schema.
- * This is a basic implementation that handles common Zod types.
- */
-export function zodToJsonSchema(zodSchema) {
-    function convertZodType(schema) {
-        const def = schema._def;
-        switch (def.typeName) {
-            case 'ZodString':
-                const stringSchema = { type: 'string' };
-                if (def.description) {
-                    stringSchema.description = def.description;
-                }
-                return stringSchema;
-            case 'ZodNumber':
-                const numberSchema = { type: 'number' };
-                if (def.description) {
-                    numberSchema.description = def.description;
-                }
-                return numberSchema;
-            case 'ZodBoolean':
-                const booleanSchema = { type: 'boolean' };
-                if (def.description) {
-                    booleanSchema.description = def.description;
-                }
-                return booleanSchema;
-            case 'ZodArray':
-                return {
-                    type: 'array',
-                    items: convertZodType(def.type),
-                    ...(def.description && { description: def.description })
-                };
-            case 'ZodObject':
-                const properties = {};
-                const required = [];
-                for (const [key, value] of Object.entries(def.shape())) {
-                    properties[key] = convertZodType(value);
-                    // Check if the field is required (not optional)
-                    const zodValue = value;
-                    if (!zodValue._def.typeName?.includes('Optional') &&
-                        zodValue._def.typeName !== 'ZodOptional') {
-                        required.push(key);
-                    }
-                }
-                const objectSchema = {
-                    type: 'object',
-                    properties,
-                    additionalProperties: false
-                };
-                if (required.length > 0) {
-                    objectSchema.required = required;
-                }
-                if (def.description) {
-                    objectSchema.description = def.description;
-                }
-                return objectSchema;
-            case 'ZodOptional':
-                return convertZodType(def.innerType);
-            case 'ZodNullable':
-                const innerSchema = convertZodType(def.innerType);
-                return {
-                    ...innerSchema,
-                    nullable: true
-                };
-            case 'ZodUnion':
-                return {
-                    anyOf: def.options.map((option) => convertZodType(option))
-                };
-            case 'ZodEnum':
-                return {
-                    type: 'string',
-                    enum: def.values,
-                    ...(def.description && { description: def.description })
-                };
-            case 'ZodLiteral':
-                return {
-                    type: typeof def.value,
-                    const: def.value,
-                    ...(def.description && { description: def.description })
-                };
-            case 'ZodRecord':
-                return {
-                    type: 'object',
-                    additionalProperties: convertZodType(def.valueType),
-                    ...(def.description && { description: def.description })
-                };
-            default:
-                // Fallback for unknown types
-                return {
-                    type: 'string',
-                    description: def.description || `Unsupported Zod type: ${def.typeName}`
-                };
-        }
-    }
-    return convertZodType(zodSchema);
-}
-/**
- * Extract descriptions from Zod schema and convert them to field descriptions.
- */
-export function extractZodDescriptions(zodSchema) {
-    const descriptions = {};
-    function extractFromType(schema, path = '') {
-        const def = schema._def;
-        if (def.typeName === 'ZodObject') {
-            for (const [key, value] of Object.entries(def.shape())) {
-                const currentPath = path ? `${path}.${key}` : key;
-                const zodValue = value;
-                if (zodValue._def.description) {
-                    descriptions[currentPath] = zodValue._def.description;
-                }
-                extractFromType(zodValue, currentPath);
-            }
-        }
-        else if (def.typeName === 'ZodOptional' || def.typeName === 'ZodNullable') {
-            extractFromType(def.innerType, path);
-        }
-        else if (def.typeName === 'ZodArray') {
-            extractFromType(def.type, path);
-        }
-    }
-    extractFromType(zodSchema);
-    return descriptions;
-}