@hookflo/tern 4.3.0-beta.0 → 4.3.0-beta.1

package/dist/normalization/storage/memory.js

@@ -1,39 +0,0 @@
-"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

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

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

@@ -1,22 +0,0 @@
-"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

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

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

@@ -1,25 +0,0 @@
-"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

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

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

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.paymentBaseTemplate = void 0;
-exports.paymentBaseTemplate = {
-    id: 'payment_v1',
-    category: 'payment',
-    version: '1.0.0',
-    fields: [
-        {
-            id: 'event_type', name: 'event_type', type: 'string', required: true, description: 'Type of payment event',
-        },
-        {
-            id: 'amount', name: 'amount', type: 'number', required: true, description: 'Amount in the smallest currency unit',
-        },
-        {
-            id: 'currency', name: 'currency', type: 'string', required: true, description: 'Three-letter currency code',
-        },
-        {
-            id: 'transaction_id', name: 'transaction_id', type: 'string', required: true, description: 'Unique transaction identifier',
-        },
-        {
-            id: 'customer_id', name: 'customer_id', type: 'string', required: false, description: 'Customer identifier',
-        },
-    ],
-};

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

@@ -1,6 +0,0 @@
-import { BaseTemplate, TemplateCategory } from '../types';
-export declare const templateRegistry: {
-    getById(id: string): BaseTemplate | undefined;
-    listByCategory(category: TemplateCategory): BaseTemplate[];
-    listAll(): BaseTemplate[];
-};

package/dist/normalization/templates/registry.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.templateRegistry = void 0;
-const payment_1 = require("./base/payment");
-const auth_1 = require("./base/auth");
-const ecommerce_1 = require("./base/ecommerce");
-const templates = {
-    [payment_1.paymentBaseTemplate.id]: payment_1.paymentBaseTemplate,
-    [auth_1.authBaseTemplate.id]: auth_1.authBaseTemplate,
-    [ecommerce_1.ecommerceBaseTemplate.id]: ecommerce_1.ecommerceBaseTemplate,
-};
-exports.templateRegistry = {
-    getById(id) {
-        return templates[id];
-    },
-    listByCategory(category) {
-        return Object.values(templates).filter((t) => t.category === category);
-    },
-    listAll() {
-        return Object.values(templates);
-    },
-};

package/dist/normalization/transformer/engine.d.ts

@@ -1,11 +0,0 @@
-import { NormalizedResult, TransformParams } from '../types';
-import { StorageAdapter } from '../storage/interface';
-import { SchemaValidator } from './validator';
-export declare class NormalizationEngine {
-    private readonly storage;
-    private readonly validator;
-    constructor(storage: StorageAdapter, validator?: SchemaValidator);
-    transform(params: TransformParams): Promise<NormalizedResult>;
-    private extractValue;
-    private applyTransform;
-}

package/dist/normalization/transformer/engine.js

@@ -1,86 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NormalizationEngine = void 0;
-const registry_1 = require("../templates/registry");
-const validator_1 = require("./validator");
-class NormalizationEngine {
-    constructor(storage, validator = new validator_1.SchemaValidator()) {
-        this.storage = storage;
-        this.validator = validator;
-    }
-    async transform(params) {
-        const { rawPayload, provider, schemaId } = params;
-        const schema = await this.storage.getSchema(schemaId);
-        if (!schema)
-            throw new Error(`Schema not found: ${schemaId}`);
-        const baseTemplate = await this.storage.getBaseTemplate(schema.baseTemplateId) || registry_1.templateRegistry.getById(schema.baseTemplateId);
-        if (!baseTemplate)
-            throw new Error(`Base template not found: ${schema.baseTemplateId}`);
-        const validation = this.validator.validateSchema(schema, baseTemplate);
-        if (!validation.valid) {
-            throw new Error(`Invalid schema: ${validation.errors.join('; ')}`);
-        }
-        const providerMapping = schema.providerMappings.find((m) => m.provider === provider);
-        if (!providerMapping)
-            throw new Error(`No mapping found for provider: ${provider}`);
-        const normalized = {};
-        for (const field of schema.fields) {
-            if (!field.enabled)
-                continue;
-            const mapping = providerMapping.fieldMappings.find((m) => m.schemaFieldId === field.id);
-            if (mapping) {
-                const value = this.extractValue(rawPayload, mapping.providerPath);
-                const finalValue = this.applyTransform(value, mapping.transform);
-                normalized[field.name] = finalValue ?? field.defaultValue;
-            }
-            else if (field.required) {
-                if (field.defaultValue !== undefined) {
-                    normalized[field.name] = field.defaultValue;
-                }
-                else {
-                    throw new Error(`Required field ${field.name} has no mapping`);
-                }
-            }
-        }
-        const outValidation = this.validator.validateOutput(normalized, schema, baseTemplate);
-        if (!outValidation.valid) {
-            throw new Error(`Normalized output invalid: ${outValidation.errors.join('; ')}`);
-        }
-        return {
-            normalized,
-            meta: {
-                provider,
-                schemaId,
-                schemaVersion: schema.baseTemplateId,
-                transformedAt: new Date(),
-            },
-        };
-    }
-    extractValue(obj, path) {
-        if (!path)
-            return undefined;
-        return path.split('.').reduce((acc, key) => (acc == null ? undefined : acc[key]), obj);
-    }
-    applyTransform(value, transform) {
-        if (transform == null)
-            return value;
-        if (value == null)
-            return value;
-        if (transform === 'toUpperCase')
-            return String(value).toUpperCase();
-        if (transform === 'toLowerCase')
-            return String(value).toLowerCase();
-        if (transform === 'toNumber')
-            return typeof value === 'number' ? value : Number(value);
-        if (transform.startsWith('divide:')) {
-            const denominator = Number(transform.split(':')[1]);
-            return Number(value) / denominator;
-        }
-        if (transform.startsWith('multiply:')) {
-            const factor = Number(transform.split(':')[1]);
-            return Number(value) * factor;
-        }
-        return value;
-    }
-}
-exports.NormalizationEngine = NormalizationEngine;

package/dist/normalization/transformer/validator.d.ts

@@ -1,12 +0,0 @@
-import { BaseTemplate, UserSchema } from '../types';
-export declare class SchemaValidator {
-    validateSchema(userSchema: UserSchema, baseTemplate: BaseTemplate): {
-        valid: boolean;
-        errors: string[];
-    };
-    validateOutput(output: Record<string, unknown>, userSchema: UserSchema, baseTemplate: BaseTemplate): {
-        valid: boolean;
-        errors: string[];
-    };
-    private matchesType;
-}

package/dist/normalization/transformer/validator.js

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaValidator = void 0;
-class SchemaValidator {
-    validateSchema(userSchema, baseTemplate) {
-        const errors = [];
-        // Ensure required base fields exist and are enabled or have defaults
-        for (const baseField of baseTemplate.fields) {
-            if (!baseField.required)
-                continue;
-            const userField = userSchema.fields.find((f) => f.id === baseField.id);
-            if (!userField) {
-                errors.push(`Missing required field in schema: ${baseField.id}`);
-                continue;
-            }
-            if (!userField.enabled && baseField.defaultValue === undefined) {
-                errors.push(`Required field disabled without default: ${baseField.id}`);
-            }
-            if (userField.type !== baseField.type) {
-                errors.push(`Type mismatch for field ${baseField.id}: expected ${baseField.type}, got ${userField.type}`);
-            }
-        }
-        return { valid: errors.length === 0, errors };
-    }
-    validateOutput(output, userSchema, baseTemplate) {
-        const errors = [];
-        for (const field of userSchema.fields) {
-            if (!field.enabled)
-                continue;
-            const value = output[field.name];
-            if (value === undefined) {
-                if (field.required)
-                    errors.push(`Missing required field in output: ${field.name}`);
-                continue;
-            }
-            if (!this.matchesType(value, field.type)) {
-                errors.push(`Type mismatch for output field ${field.name}`);
-            }
-        }
-        return { valid: errors.length === 0, errors };
-    }
-    matchesType(value, type) {
-        if (type === 'number')
-            return typeof value === 'number' && !Number.isNaN(value);
-        if (type === 'string')
-            return typeof value === 'string';
-        if (type === 'boolean')
-            return typeof value === 'boolean';
-        if (type === 'object')
-            return typeof value === 'object' && value !== null && !Array.isArray(value);
-        if (type === 'array')
-            return Array.isArray(value);
-        return true;
-    }
-}
-exports.SchemaValidator = SchemaValidator;

package/dist/normalization/types.d.ts

@@ -1,79 +0,0 @@
-export type TemplateCategory = 'payment' | 'auth' | 'ecommerce';
-export interface TemplateField {
-    id: string;
-    name: string;
-    type: 'string' | 'number' | 'boolean' | 'object' | 'array';
-    required: boolean;
-    description?: string;
-    defaultValue?: unknown;
-}
-export interface BaseTemplate {
-    id: string;
-    category: TemplateCategory;
-    version: string;
-    fields: TemplateField[];
-}
-export interface UserSchemaField {
-    id: string;
-    name: string;
-    type: TemplateField['type'];
-    required: boolean;
-    enabled: boolean;
-    defaultValue?: unknown;
-}
-export interface FieldMapping {
-    schemaFieldId: string;
-    providerPath: string;
-    transform?: string;
-}
-export interface ProviderMapping {
-    provider: string;
-    fieldMappings: FieldMapping[];
-}
-export interface UserSchema {
-    id: string;
-    userId: string;
-    baseTemplateId: string;
-    category: TemplateCategory;
-    fields: UserSchemaField[];
-    providerMappings: ProviderMapping[];
-    createdAt: Date;
-    updatedAt: Date;
-}
-export interface NormalizedPayloadMeta {
-    provider: string;
-    schemaId: string;
-    schemaVersion: string;
-    transformedAt: Date;
-}
-export interface NormalizedResult {
-    normalized: Record<string, unknown>;
-    meta: NormalizedPayloadMeta;
-}
-export interface CreateSchemaInput {
-    userId: string;
-    baseTemplateId: string;
-    category: TemplateCategory;
-    fields: UserSchemaField[];
-    providerMappings: ProviderMapping[];
-}
-export interface UpdateSchemaInput {
-    fields?: UserSchemaField[];
-    providerMappings?: ProviderMapping[];
-}
-export interface ProviderInfoField {
-    path: string;
-    type?: TemplateField['type'];
-    description?: string;
-}
-export interface ProviderInfo {
-    id: string;
-    name: string;
-    category: TemplateCategory;
-    samplePaths?: ProviderInfoField[];
-}
-export interface TransformParams {
-    rawPayload: unknown;
-    provider: string;
-    schemaId: string;
-}

package/dist/normalization/types.js

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