@hookflo/tern 1.0.6 → 2.0.2-experimental.0

package/dist/index.js

@@ -14,22 +14,25 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCustomVerifier = exports.createAlgorithmVerifier = exports.validateSignatureConfig = exports.getPlatformsUsingAlgorithm = exports.platformUsesAlgorithm = exports.getPlatformAlgorithmConfig = exports.WebhookVerificationService = void 0;
+exports.getPlatformsByCategory = exports.getPlatformNormalizationCategory = exports.normalizePayload = exports.createCustomVerifier = exports.createAlgorithmVerifier = exports.validateSignatureConfig = exports.getPlatformsUsingAlgorithm = exports.platformUsesAlgorithm = exports.getPlatformAlgorithmConfig = exports.WebhookVerificationService = void 0;
 const algorithms_1 = require("./verifiers/algorithms");
 const custom_algorithms_1 = require("./verifiers/custom-algorithms");
 const algorithms_2 = require("./platforms/algorithms");
+const simple_1 = require("./normalization/simple");
 class WebhookVerificationService {
     static async verify(request, config) {
         const verifier = this.getVerifier(config);
-        const result = await verifier.verify(request);
+        const result = await verifier.verify(request.clone());
         // Ensure the platform is set correctly in the result
         if (result.isValid) {
             result.platform = config.platform;
+            if (config.normalize) {
+                result.payload = (0, simple_1.normalizePayload)(config.platform, result.payload, config.normalize);
+            }
         }
         return result;
     }
     static getVerifier(config) {
-        const platform = config.platform.toLowerCase();
         // If a custom signature config is provided, use the new algorithm-based framework
         if (config.signatureConfig) {
             return this.createAlgorithmBasedVerifier(config);
@@ -50,9 +53,8 @@ class WebhookVerificationService {
         return (0, algorithms_1.createAlgorithmVerifier)(secret, signatureConfig, config.platform, toleranceInSeconds);
     }
     static getLegacyVerifier(config) {
-        const platform = config.platform.toLowerCase();
         // For legacy support, we'll use the algorithm-based approach
-        const platformConfig = (0, algorithms_2.getPlatformAlgorithmConfig)(platform);
+        const platformConfig = (0, algorithms_2.getPlatformAlgorithmConfig)(config.platform);
         const configWithSignature = {
             ...config,
             signatureConfig: platformConfig.signatureConfig,
@@ -60,30 +62,72 @@ class WebhookVerificationService {
         return this.createAlgorithmBasedVerifier(configWithSignature);
     }
     // New method to create verifier using platform algorithm config
-    static async verifyWithPlatformConfig(request, platform, secret, toleranceInSeconds = 300) {
+    static async verifyWithPlatformConfig(request, platform, secret, toleranceInSeconds = 300, normalize = false) {
         const platformConfig = (0, algorithms_2.getPlatformAlgorithmConfig)(platform);
         const config = {
             platform,
             secret,
             toleranceInSeconds,
             signatureConfig: platformConfig.signatureConfig,
+            normalize,
         };
-        return await this.verify(request, config);
+        return this.verify(request, config);
+    }
+    static async verifyAny(request, secrets, toleranceInSeconds = 300, normalize = false) {
+        const requestClone = request.clone();
+        const detectedPlatform = this.detectPlatform(requestClone);
+        if (detectedPlatform !== 'unknown' && secrets[detectedPlatform]) {
+            return this.verifyWithPlatformConfig(requestClone, detectedPlatform, secrets[detectedPlatform], toleranceInSeconds, normalize);
+        }
+        for (const [platform, secret] of Object.entries(secrets)) {
+            if (!secret) {
+                continue;
+            }
+            const result = await this.verifyWithPlatformConfig(requestClone, platform.toLowerCase(), secret, toleranceInSeconds, normalize);
+            if (result.isValid) {
+                return result;
+            }
+        }
+        return {
+            isValid: false,
+            error: 'Unable to verify webhook with provided platform secrets',
+            errorCode: 'VERIFICATION_ERROR',
+            platform: detectedPlatform,
+        };
+    }
+    static detectPlatform(request) {
+        const headers = request.headers;
+        if (headers.has('stripe-signature'))
+            return 'stripe';
+        if (headers.has('x-hub-signature-256'))
+            return 'github';
+        if (headers.has('svix-signature'))
+            return 'clerk';
+        if (headers.has('webhook-signature'))
+            return 'dodopayments';
+        if (headers.has('x-gitlab-token'))
+            return 'gitlab';
+        if (headers.has('x-polar-signature'))
+            return 'polar';
+        if (headers.has('x-shopify-hmac-sha256'))
+            return 'shopify';
+        if (headers.has('x-vercel-signature'))
+            return 'vercel';
+        if (headers.has('x-webhook-token') && headers.has('x-webhook-id'))
+            return 'supabase';
+        return 'unknown';
     }
     // Helper method to get all platforms using a specific algorithm
     static getPlatformsUsingAlgorithm(algorithm) {
-        const { getPlatformsUsingAlgorithm } = require('./platforms/algorithms');
-        return getPlatformsUsingAlgorithm(algorithm);
+        return (0, algorithms_2.getPlatformsUsingAlgorithm)(algorithm);
     }
     // Helper method to check if a platform uses a specific algorithm
     static platformUsesAlgorithm(platform, algorithm) {
-        const { platformUsesAlgorithm } = require('./platforms/algorithms');
-        return platformUsesAlgorithm(platform, algorithm);
+        return (0, algorithms_2.platformUsesAlgorithm)(platform, algorithm);
     }
     // Helper method to validate signature config
     static validateSignatureConfig(config) {
-        const { validateSignatureConfig } = require('./platforms/algorithms');
-        return validateSignatureConfig(config);
+        return (0, algorithms_2.validateSignatureConfig)(config);
     }
     // Simple token-based verification for platforms like Supabase
     static async verifyTokenBased(request, webhookId, webhookToken) {
@@ -94,6 +138,7 @@ class WebhookVerificationService {
                 return {
                     isValid: false,
                     error: 'Missing required headers: x-webhook-id and x-webhook-token',
+                    errorCode: 'MISSING_TOKEN',
                     platform: 'custom',
                 };
             }
@@ -103,6 +148,7 @@ class WebhookVerificationService {
                 return {
                     isValid: false,
                     error: 'Invalid webhook ID or token',
+                    errorCode: 'INVALID_TOKEN',
                     platform: 'custom',
                 };
             }
@@ -117,7 +163,7 @@ class WebhookVerificationService {
             return {
                 isValid: true,
                 platform: 'custom',
-                payload,
+                payload: payload,
                 metadata: {
                     id: idHeader,
                     algorithm: 'token-based',
@@ -128,6 +174,7 @@ class WebhookVerificationService {
             return {
                 isValid: false,
                 error: `Token-based verification error: ${error.message}`,
+                errorCode: 'VERIFICATION_ERROR',
                 platform: 'custom',
             };
         }
@@ -144,4 +191,9 @@ var algorithms_4 = require("./verifiers/algorithms");
 Object.defineProperty(exports, "createAlgorithmVerifier", { enumerable: true, get: function () { return algorithms_4.createAlgorithmVerifier; } });
 var custom_algorithms_2 = require("./verifiers/custom-algorithms");
 Object.defineProperty(exports, "createCustomVerifier", { enumerable: true, get: function () { return custom_algorithms_2.createCustomVerifier; } });
+var simple_2 = require("./normalization/simple");
+Object.defineProperty(exports, "normalizePayload", { enumerable: true, get: function () { return simple_2.normalizePayload; } });
+Object.defineProperty(exports, "getPlatformNormalizationCategory", { enumerable: true, get: function () { return simple_2.getPlatformNormalizationCategory; } });
+Object.defineProperty(exports, "getPlatformsByCategory", { enumerable: true, get: function () { return simple_2.getPlatformsByCategory; } });
+__exportStar(require("./adapters"), exports);
 exports.default = WebhookVerificationService;

package/dist/nextjs.d.ts

@@ -0,0 +1,2 @@
+export { createWebhookHandler } from './adapters/nextjs';
+export type { NextWebhookHandlerOptions } from './adapters/nextjs';

package/dist/nextjs.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWebhookHandler = void 0;
+var nextjs_1 = require("./adapters/nextjs");
+Object.defineProperty(exports, "createWebhookHandler", { enumerable: true, get: function () { return nextjs_1.createWebhookHandler; } });

package/dist/normalization/index.d.ts

@@ -0,0 +1,20 @@
+import { BaseTemplate, CreateSchemaInput, NormalizedResult, ProviderInfo, TemplateCategory, TransformParams, UpdateSchemaInput, UserSchema } from './types';
+import { StorageAdapter } from './storage/interface';
+export declare class Normalizer {
+    private readonly storage;
+    private engine;
+    constructor(storage?: StorageAdapter);
+    getBaseTemplates(): Promise<BaseTemplate[]>;
+    getProviders(category?: TemplateCategory): Promise<ProviderInfo[]>;
+    createSchema(input: CreateSchemaInput): Promise<UserSchema>;
+    updateSchema(schemaId: string, updates: UpdateSchemaInput): Promise<void>;
+    getSchema(id: string): Promise<UserSchema | null>;
+    transform(params: TransformParams): Promise<NormalizedResult>;
+    validateSchema(schema: UserSchema): Promise<{
+        valid: boolean;
+        errors: string[];
+    }>;
+}
+export * from './types';
+export * from './storage/interface';
+export { InMemoryStorageAdapter } from './storage/memory';

package/dist/normalization/index.js

@@ -0,0 +1,78 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryStorageAdapter = exports.Normalizer = void 0;
+const registry_1 = require("./providers/registry");
+const registry_2 = require("./templates/registry");
+const memory_1 = require("./storage/memory");
+const engine_1 = require("./transformer/engine");
+const validator_1 = require("./transformer/validator");
+class Normalizer {
+    constructor(storage = new memory_1.InMemoryStorageAdapter()) {
+        this.storage = storage;
+        this.engine = new engine_1.NormalizationEngine(storage, new validator_1.SchemaValidator());
+    }
+    async getBaseTemplates() {
+        return this.storage.listBaseTemplates();
+    }
+    async getProviders(category) {
+        return registry_1.providerRegistry.list(category);
+    }
+    async createSchema(input) {
+        const schema = {
+            id: generateId(),
+            userId: input.userId,
+            baseTemplateId: input.baseTemplateId,
+            category: input.category,
+            fields: input.fields,
+            providerMappings: input.providerMappings,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+        await this.storage.saveSchema(schema);
+        return schema;
+    }
+    async updateSchema(schemaId, updates) {
+        await this.storage.updateSchema(schemaId, updates);
+    }
+    async getSchema(id) {
+        return this.storage.getSchema(id);
+    }
+    async transform(params) {
+        return this.engine.transform(params);
+    }
+    async validateSchema(schema) {
+        const base = (await this.storage.getBaseTemplate(schema.baseTemplateId))
+            ?? registry_2.templateRegistry.getById(schema.baseTemplateId);
+        if (!base) {
+            return {
+                valid: false,
+                errors: [`Base template not found: ${schema.baseTemplateId}`],
+            };
+        }
+        const validator = new validator_1.SchemaValidator();
+        return validator.validateSchema(schema, base);
+    }
+}
+exports.Normalizer = Normalizer;
+function generateId() {
+    // Simple non-crypto unique ID generator for framework default
+    return (`sch_${Math.random().toString(36).slice(2, 10)}${Date.now().toString(36)}`);
+}
+__exportStar(require("./types"), exports);
+__exportStar(require("./storage/interface"), exports);
+var memory_2 = require("./storage/memory");
+Object.defineProperty(exports, "InMemoryStorageAdapter", { enumerable: true, get: function () { return memory_2.InMemoryStorageAdapter; } });

package/dist/normalization/providers/payment/paypal.d.ts

@@ -0,0 +1,2 @@
+import { ProviderMapping } from '../../types';
+export declare const paypalDefaultMapping: ProviderMapping;

package/dist/normalization/providers/payment/paypal.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paypalDefaultMapping = void 0;
+exports.paypalDefaultMapping = {
+    provider: 'paypal',
+    fieldMappings: [
+        { schemaFieldId: 'event_type', providerPath: 'event_type' },
+        { schemaFieldId: 'amount', providerPath: 'resource.amount.value', transform: 'toNumber' },
+        { schemaFieldId: 'currency', providerPath: 'resource.amount.currency_code', transform: 'toUpperCase' },
+        { schemaFieldId: 'transaction_id', providerPath: 'resource.id' },
+    ],
+};

package/dist/normalization/providers/payment/razorpay.d.ts

@@ -0,0 +1,2 @@
+import { ProviderMapping } from '../../types';
+export declare const razorpayDefaultMapping: ProviderMapping;

package/dist/normalization/providers/payment/razorpay.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.razorpayDefaultMapping = void 0;
+exports.razorpayDefaultMapping = {
+    provider: 'razorpay',
+    fieldMappings: [
+        { schemaFieldId: 'event_type', providerPath: 'event' },
+        { schemaFieldId: 'amount', providerPath: 'payload.payment.entity.amount' },
+        { schemaFieldId: 'currency', providerPath: 'payload.payment.entity.currency', transform: 'toUpperCase' },
+        { schemaFieldId: 'transaction_id', providerPath: 'payload.payment.entity.id' },
+        { schemaFieldId: 'customer_id', providerPath: 'payload.payment.entity.contact' },
+    ],
+};

package/dist/normalization/providers/payment/stripe.d.ts

@@ -0,0 +1,2 @@
+import { ProviderMapping } from '../../types';
+export declare const stripeDefaultMapping: ProviderMapping;

package/dist/normalization/providers/payment/stripe.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripeDefaultMapping = void 0;
+exports.stripeDefaultMapping = {
+    provider: 'stripe',
+    fieldMappings: [
+        { schemaFieldId: 'event_type', providerPath: 'type' },
+        { schemaFieldId: 'amount', providerPath: 'data.object.amount_received' },
+        { schemaFieldId: 'currency', providerPath: 'data.object.currency', transform: 'toUpperCase' },
+        { schemaFieldId: 'transaction_id', providerPath: 'data.object.id' },
+        { schemaFieldId: 'customer_id', providerPath: 'data.object.customer' },
+    ],
+};

package/dist/normalization/providers/registry.d.ts

@@ -0,0 +1,5 @@
+import { ProviderInfo } from '../types';
+export declare const providerRegistry: {
+    list(category?: ProviderInfo["category"]): ProviderInfo[];
+    getById(id: string): ProviderInfo | undefined;
+};

package/dist/normalization/providers/registry.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.providerRegistry = void 0;
+const providers = [
+    { id: 'stripe', name: 'Stripe', category: 'payment' },
+    { id: 'razorpay', name: 'Razorpay', category: 'payment' },
+    { id: 'paypal', name: 'PayPal', category: 'payment' },
+    { id: 'clerk', name: 'Clerk', category: 'auth' },
+    { id: 'auth0', name: 'Auth0', category: 'auth' },
+    { id: 'supabase', name: 'Supabase', category: 'auth' },
+    { id: 'shopify', name: 'Shopify', category: 'ecommerce' },
+    { id: 'woocommerce', name: 'WooCommerce', category: 'ecommerce' },
+];
+exports.providerRegistry = {
+    list(category) {
+        if (!category)
+            return providers;
+        return providers.filter((p) => p.category === category);
+    },
+    getById(id) {
+        return providers.find((p) => p.id === id);
+    },
+};

package/dist/normalization/simple.d.ts

@@ -0,0 +1,4 @@
+import { AnyNormalizedWebhook, NormalizeOptions, NormalizationCategory, WebhookPlatform } from '../types';
+export declare function getPlatformNormalizationCategory(platform: WebhookPlatform): NormalizationCategory | null;
+export declare function getPlatformsByCategory(category: NormalizationCategory): WebhookPlatform[];
+export declare function normalizePayload(platform: WebhookPlatform, payload: any, normalize?: boolean | NormalizeOptions): AnyNormalizedWebhook | unknown;

package/dist/normalization/simple.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPlatformNormalizationCategory = getPlatformNormalizationCategory;
+exports.getPlatformsByCategory = getPlatformsByCategory;
+exports.normalizePayload = normalizePayload;
+function readPath(payload, path) {
+    return path.split('.').reduce((acc, key) => {
+        if (acc === undefined || acc === null) {
+            return undefined;
+        }
+        return acc[key];
+    }, payload);
+}
+const platformNormalizers = {
+    stripe: {
+        platform: 'stripe',
+        category: 'payment',
+        normalize: (payload) => ({
+            category: 'payment',
+            event: readPath(payload, 'type') === 'payment_intent.succeeded'
+                ? 'payment.succeeded'
+                : 'payment.unknown',
+            amount: readPath(payload, 'data.object.amount_received')
+                ?? readPath(payload, 'data.object.amount'),
+            currency: String(readPath(payload, 'data.object.currency') ?? '').toUpperCase() || undefined,
+            customer_id: readPath(payload, 'data.object.customer'),
+            transaction_id: readPath(payload, 'data.object.id'),
+            metadata: {},
+            occurred_at: new Date().toISOString(),
+        }),
+    },
+    polar: {
+        platform: 'polar',
+        category: 'payment',
+        normalize: (payload) => ({
+            category: 'payment',
+            event: readPath(payload, 'event') === 'payment.completed'
+                ? 'payment.succeeded'
+                : 'payment.unknown',
+            amount: readPath(payload, 'payload.amount_cents'),
+            currency: String(readPath(payload, 'payload.currency_code') ?? '').toUpperCase() || undefined,
+            customer_id: readPath(payload, 'payload.customer_id'),
+            transaction_id: readPath(payload, 'payload.transaction_id'),
+            metadata: {},
+            occurred_at: new Date().toISOString(),
+        }),
+    },
+    clerk: {
+        platform: 'clerk',
+        category: 'auth',
+        normalize: (payload) => ({
+            category: 'auth',
+            event: readPath(payload, 'type') || 'auth.unknown',
+            user_id: readPath(payload, 'data.id'),
+            email: readPath(payload, 'data.email_addresses.0.email_address'),
+            metadata: {},
+            occurred_at: new Date().toISOString(),
+        }),
+    },
+    supabase: {
+        platform: 'supabase',
+        category: 'auth',
+        normalize: (payload) => ({
+            category: 'auth',
+            event: readPath(payload, 'type') || readPath(payload, 'event') || 'auth.unknown',
+            user_id: readPath(payload, 'record.id') || readPath(payload, 'id'),
+            email: readPath(payload, 'record.email') || readPath(payload, 'email'),
+            metadata: {},
+            occurred_at: new Date().toISOString(),
+        }),
+    },
+    vercel: {
+        platform: 'vercel',
+        category: 'infrastructure',
+        normalize: (payload) => ({
+            category: 'infrastructure',
+            event: readPath(payload, 'type') || 'deployment.unknown',
+            project_id: readPath(payload, 'payload.project.id'),
+            deployment_id: readPath(payload, 'payload.deployment.id'),
+            status: 'unknown',
+            metadata: {},
+            occurred_at: new Date().toISOString(),
+        }),
+    },
+};
+function getPlatformNormalizationCategory(platform) {
+    return platformNormalizers[platform]?.category || null;
+}
+function getPlatformsByCategory(category) {
+    return Object.values(platformNormalizers)
+        .filter((spec) => !!spec)
+        .filter((spec) => spec.category === category)
+        .map((spec) => spec.platform);
+}
+function resolveNormalizeOptions(normalize) {
+    if (typeof normalize === 'boolean') {
+        return {
+            enabled: normalize,
+            category: undefined,
+            includeRaw: true,
+        };
+    }
+    return {
+        enabled: normalize?.enabled ?? true,
+        category: normalize?.category,
+        includeRaw: normalize?.includeRaw ?? true,
+    };
+}
+function buildUnknownNormalizedPayload(platform, payload, category, includeRaw, warning) {
+    return {
+        category: category || 'infrastructure',
+        event: payload?.type ?? payload?.event ?? 'unknown',
+        _platform: platform,
+        _raw: includeRaw ? payload : undefined,
+        warning,
+        occurred_at: new Date().toISOString(),
+    };
+}
+function normalizePayload(platform, payload, normalize) {
+    const options = resolveNormalizeOptions(normalize);
+    if (!options.enabled) {
+        return payload;
+    }
+    const spec = platformNormalizers[platform];
+    const inferredCategory = spec?.category;
+    if (!spec) {
+        return buildUnknownNormalizedPayload(platform, payload, options.category, options.includeRaw);
+    }
+    if (options.category && options.category !== inferredCategory) {
+        return buildUnknownNormalizedPayload(platform, payload, inferredCategory, options.includeRaw, `Requested normalization category '${options.category}' does not match platform category '${inferredCategory}'`);
+    }
+    const normalized = spec.normalize(payload);
+    return {
+        ...normalized,
+        _platform: platform,
+        _raw: options.includeRaw ? payload : undefined,
+    };
+}

package/dist/normalization/storage/interface.d.ts

@@ -0,0 +1,13 @@
+import { BaseTemplate, UpdateSchemaInput, UserSchema } from '../types';
+export interface StorageAdapter {
+    saveSchema(schema: UserSchema): Promise<void>;
+    getSchema(id: string): Promise<UserSchema | null>;
+    updateSchema(id: string, updates: UpdateSchemaInput): Promise<void>;
+    deleteSchema(id: string): Promise<void>;
+    listSchemas(userId: string): Promise<UserSchema[]>;
+    getBaseTemplate(id: string): Promise<BaseTemplate | null>;
+    listBaseTemplates(): Promise<BaseTemplate[]>;
+}
+export interface NormalizationStorageOptions {
+    adapter: StorageAdapter;
+}

package/dist/normalization/storage/interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/normalization/storage/memory.d.ts

@@ -0,0 +1,12 @@
+import { BaseTemplate, UpdateSchemaInput, UserSchema } from '../types';
+import { StorageAdapter } from './interface';
+export declare class InMemoryStorageAdapter implements StorageAdapter {
+    private schemas;
+    saveSchema(schema: UserSchema): Promise<void>;
+    getSchema(id: string): Promise<UserSchema | null>;
+    updateSchema(id: string, updates: UpdateSchemaInput): Promise<void>;
+    deleteSchema(id: string): Promise<void>;
+    listSchemas(userId: string): Promise<UserSchema[]>;
+    getBaseTemplate(id: string): Promise<BaseTemplate | null>;
+    listBaseTemplates(): Promise<BaseTemplate[]>;
+}

package/dist/normalization/storage/memory.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryStorageAdapter = void 0;
+const registry_1 = require("../templates/registry");
+class InMemoryStorageAdapter {
+    constructor() {
+        this.schemas = new Map();
+    }
+    async saveSchema(schema) {
+        this.schemas.set(schema.id, schema);
+    }
+    async getSchema(id) {
+        return this.schemas.get(id) ?? null;
+    }
+    async updateSchema(id, updates) {
+        const existing = this.schemas.get(id);
+        if (!existing)
+            return;
+        const updated = {
+            ...existing,
+            ...updates,
+            updatedAt: new Date(),
+        };
+        this.schemas.set(id, updated);
+    }
+    async deleteSchema(id) {
+        this.schemas.delete(id);
+    }
+    async listSchemas(userId) {
+        return Array.from(this.schemas.values()).filter((s) => s.userId === userId);
+    }
+    async getBaseTemplate(id) {
+        return registry_1.templateRegistry.getById(id) ?? null;
+    }
+    async listBaseTemplates() {
+        return registry_1.templateRegistry.listAll();
+    }
+}
+exports.InMemoryStorageAdapter = InMemoryStorageAdapter;

package/dist/normalization/templates/base/auth.d.ts

@@ -0,0 +1,2 @@
+import { BaseTemplate } from '../../types';
+export declare const authBaseTemplate: BaseTemplate;

package/dist/normalization/templates/base/auth.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authBaseTemplate = void 0;
+exports.authBaseTemplate = {
+    id: 'auth_v1',
+    category: 'auth',
+    version: '1.0.0',
+    fields: [
+        {
+            id: 'event_type', name: 'event_type', type: 'string', required: true,
+        },
+        {
+            id: 'user_id', name: 'user_id', type: 'string', required: true,
+        },
+        {
+            id: 'email', name: 'email', type: 'string', required: false,
+        },
+        {
+            id: 'status', name: 'status', type: 'string', required: true,
+        },
+    ],
+};

package/dist/normalization/templates/base/ecommerce.d.ts

@@ -0,0 +1,2 @@
+import { BaseTemplate } from '../../types';
+export declare const ecommerceBaseTemplate: BaseTemplate;

package/dist/normalization/templates/base/ecommerce.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ecommerceBaseTemplate = void 0;
+exports.ecommerceBaseTemplate = {
+    id: 'ecommerce_v1',
+    category: 'ecommerce',
+    version: '1.0.0',
+    fields: [
+        {
+            id: 'event_type', name: 'event_type', type: 'string', required: true,
+        },
+        {
+            id: 'order_id', name: 'order_id', type: 'string', required: true,
+        },
+        {
+            id: 'total', name: 'total', type: 'number', required: true,
+        },
+        {
+            id: 'currency', name: 'currency', type: 'string', required: true,
+        },
+        {
+            id: 'customer_id', name: 'customer_id', type: 'string', required: false,
+        },
+    ],
+};

package/dist/normalization/templates/base/payment.d.ts

@@ -0,0 +1,2 @@
+import { BaseTemplate } from '../../types';
+export declare const paymentBaseTemplate: BaseTemplate;