@glowlabs-org/events-sdk 0.1.1 → 1.0.1

package/dist/base-event.d.ts

@@ -0,0 +1,65 @@
+import { z } from "zod";
+import { ZoneName } from "./zones";
+export declare const baseEventZ: z.ZodObject<{
+    id: z.ZodString;
+    zoneId: z.ZodEffects<z.ZodNumber, number, number>;
+    zoneName: z.ZodEnum<[string, ...string[]]>;
+    schemaVersion: z.ZodEffects<z.ZodNumber, 1 | 2, number>;
+    eventType: z.ZodEnum<["audit.pushed", "audit.slashed", "audit.pfees.paid"]>;
+    timeStamp: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    zoneId: number;
+    zoneName: string;
+    schemaVersion: 1 | 2;
+    eventType: "audit.pushed" | "audit.slashed" | "audit.pfees.paid";
+    timeStamp: number;
+}, {
+    id: string;
+    zoneId: number;
+    zoneName: string;
+    schemaVersion: number;
+    eventType: "audit.pushed" | "audit.slashed" | "audit.pfees.paid";
+    timeStamp: number;
+}>;
+export interface BaseEventAuditPushedV1 {
+    id: string;
+    zoneId: number;
+    zoneName: ZoneName;
+    schemaVersion: 1;
+    eventType: "audit.pushed";
+    timeStamp: number;
+}
+export interface BaseEventAuditSlashedV1 {
+    id: string;
+    zoneId: number;
+    zoneName: ZoneName;
+    schemaVersion: 1;
+    eventType: "audit.slashed";
+    timeStamp: number;
+}
+export interface BaseEventAuditPfeesPaidV1 {
+    id: string;
+    zoneId: number;
+    zoneName: ZoneName;
+    schemaVersion: 1;
+    eventType: "audit.pfees.paid";
+    timeStamp: number;
+}
+export interface BaseEventAuditPfeesPaidV2 {
+    id: string;
+    zoneId: number;
+    zoneName: ZoneName;
+    schemaVersion: 2;
+    eventType: "audit.pfees.paid";
+    timeStamp: number;
+}
+export interface BaseEventApplicationCreatedV1 {
+    id: string;
+    zoneId: number;
+    zoneName: ZoneName;
+    schemaVersion: 1;
+    eventType: "application.created";
+    timeStamp: number;
+}
+export type BaseEvent = BaseEventAuditPushedV1 | BaseEventAuditSlashedV1 | BaseEventAuditPfeesPaidV1 | BaseEventAuditPfeesPaidV2 | BaseEventApplicationCreatedV1;

package/dist/base-event.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseEventZ = void 0;
+const zod_1 = require("zod");
+const zones_1 = require("./zones");
+const zoneIdNumbers = Object.keys(zones_1.zoneMap).map(Number);
+const zoneNames = Object.values(zones_1.zoneMap);
+exports.baseEventZ = zod_1.z.object({
+    id: zod_1.z.string().uuid(),
+    zoneId: zod_1.z.number().refine((id) => zoneIdNumbers.includes(id), {
+        message: "Invalid zoneId",
+    }),
+    zoneName: zod_1.z.enum(zoneNames),
+    schemaVersion: zod_1.z
+        .number()
+        .int()
+        .refine((v) => v === 1 || v === 2, {
+        message: "Invalid schemaVersion",
+    }),
+    eventType: zod_1.z.enum(["audit.pushed", "audit.slashed", "audit.pfees.paid"]),
+    timeStamp: zod_1.z.number().int(),
+});

package/dist/emitter.d.ts

@@ -0,0 +1,17 @@
+import { EventPayload, EventType, EventVersion } from "./types";
+interface CreateGlowEventEmitterOptions {
+    username: string;
+    password: string;
+    zoneId: number;
+    exchangePrefix?: string;
+}
+interface EmitEventArgs<T extends EventType, V extends EventVersion<T>> {
+    eventType: T;
+    schemaVersion: V;
+    payload: EventPayload<T, V>;
+}
+export declare function createGlowEventEmitter({ username, password, zoneId, exchangePrefix, }: CreateGlowEventEmitterOptions): {
+    emit: <T extends EventType, V extends EventVersion<T>>(args: EmitEventArgs<T, V>) => Promise<void>;
+    disconnect: () => Promise<void>;
+};
+export {};

package/dist/emitter.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGlowEventEmitter = createGlowEventEmitter;
+const amqplib_1 = __importDefault(require("amqplib"));
+const utils_1 = require("./utils");
+const uuid_1 = require("uuid");
+const zones_1 = require("./zones");
+function createGlowEventEmitter({ username, password, zoneId, exchangePrefix = "glow.zone-", }) {
+    let amqpConnection = null;
+    let amqpChannel = null;
+    // Exchanges for global and specific zone
+    const globalExchangeName = `${exchangePrefix}0.events`;
+    const zoneExchangeName = `${exchangePrefix}${zoneId}.events`;
+    function buildAmqpUrl() {
+        const url = new URL(`amqp://${username}:${password}@turntable.proxy.rlwy.net:50784`);
+        return url.toString();
+    }
+    async function connectIfNeeded() {
+        if (!amqpConnection) {
+            amqpConnection = (await amqplib_1.default.connect(buildAmqpUrl()));
+            amqpChannel = (await amqpConnection.createChannel());
+        }
+        if (amqpChannel) {
+            await amqpChannel.assertExchange(globalExchangeName, "topic", {
+                durable: true,
+            });
+            await amqpChannel.assertExchange(zoneExchangeName, "topic", {
+                durable: true,
+            });
+        }
+    }
+    async function emit(args) {
+        const { eventType, schemaVersion, payload } = args;
+        const zoneName = zones_1.zoneMap[String(zoneId)];
+        if (!zoneName)
+            throw new Error(`Invalid zoneId: ${zoneId}`);
+        if (zoneId === 0)
+            throw new Error("Cannot emit events with zoneId 0. Use a specific zone emitter.");
+        const event = {
+            id: (0, uuid_1.v4)(),
+            eventType,
+            schemaVersion,
+            zoneId,
+            zoneName,
+            timeStamp: Date.now(),
+            payload,
+        };
+        (0, utils_1.validateZoneNameAndId)(event.zoneId, event.zoneName);
+        (0, utils_1.validateEventPayload)(event.eventType, event.schemaVersion, event);
+        const routingKey = `${event.eventType}.v${event.schemaVersion}`;
+        await connectIfNeeded();
+        // Emit to both the global and the specific zone exchange
+        amqpChannel.publish(globalExchangeName, routingKey, Buffer.from(JSON.stringify(event)), { persistent: true });
+        amqpChannel.publish(zoneExchangeName, routingKey, Buffer.from(JSON.stringify(event)), { persistent: true });
+    }
+    async function disconnect() {
+        if (amqpConnection) {
+            await amqpConnection.close();
+            amqpConnection = null;
+            amqpChannel = null;
+        }
+    }
+    return { emit, disconnect };
+}

package/dist/event-registry.d.ts

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export declare function getEventSchema(eventType: string, version: number): z.ZodTypeAny;

package/dist/event-registry.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEventSchema = getEventSchema;
+const audit_pushed_v1_1 = require("./schemas/audit-pushed.v1");
+const audit_slashed_v1_1 = require("./schemas/audit-slashed.v1");
+const audit_pfees_paid_v1_1 = require("./schemas/audit-pfees-paid.v1");
+const audit_pfees_paid_v2_1 = require("./schemas/audit-pfees-paid.v2");
+const base_event_1 = require("./base-event");
+const application_created_v1_1 = require("./schemas/application-created.v1");
+const eventTypeRegistry = {
+    "audit.pushed:v1": base_event_1.baseEventZ.extend({ payload: audit_pushed_v1_1.auditPushedV1PayloadZ }),
+    "audit.slashed:v1": base_event_1.baseEventZ.extend({ payload: audit_slashed_v1_1.auditSlashedV1PayloadZ }),
+    "audit.pfees.paid:v1": base_event_1.baseEventZ.extend({
+        payload: audit_pfees_paid_v1_1.auditPfeesPaidV1PayloadZ,
+    }),
+    "audit.pfees.paid:v2": base_event_1.baseEventZ.extend({
+        payload: audit_pfees_paid_v2_1.auditPfeesPaidV2PayloadZ,
+    }),
+    "application.created:v1": base_event_1.baseEventZ.extend({
+        payload: application_created_v1_1.applicationCreatedV1PayloadZ,
+    }),
+    // Add more event types/versions here
+};
+function getEventSchema(eventType, version) {
+    const key = `${eventType}:v${version}`;
+    return eventTypeRegistry[key];
+}

package/dist/index.d.ts

@@ -1,6 +1,3 @@
-export * from "./producer";
-export * from "./consumer";
-export * from "./schemas/auditPushed";
-export * from "./glow-listener";
-export * from "./types";
+export * from "./emitter";
+export * from "./listener";
 export * from "./admin";

package/dist/index.js

@@ -14,9 +14,6 @@ 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 });
-__exportStar(require("./producer"), exports);
-__exportStar(require("./consumer"), exports);
-__exportStar(require("./schemas/auditPushed"), exports);
-__exportStar(require("./glow-listener"), exports);
-__exportStar(require("./types"), exports);
+__exportStar(require("./emitter"), exports);
+__exportStar(require("./listener"), exports);
 __exportStar(require("./admin"), exports);

package/dist/listener.d.ts

@@ -0,0 +1,14 @@
+import type { EventType, EventVersion, EventPayload, GlowEvent } from "./types";
+interface CreateGlowEventListenerOptions {
+    username: string;
+    password: string;
+    zoneId: number;
+    queueName?: string;
+    exchangePrefix?: string;
+}
+export declare function createGlowEventListener({ username, password, zoneId, queueName, exchangePrefix, }: CreateGlowEventListenerOptions): {
+    onEvent: <T extends EventType, V extends EventVersion<T>>(eventType: T, schemaVersion: V, handler: (event: GlowEvent<EventPayload<T, V>>) => void) => void;
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+};
+export {};

package/dist/listener.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGlowEventListener = createGlowEventListener;
+const amqplib_1 = __importDefault(require("amqplib"));
+const event_registry_1 = require("./event-registry");
+const utils_1 = require("./utils");
+function createGlowEventListener({ username, password, zoneId, queueName, exchangePrefix = "glow.zone-", }) {
+    let amqpConnection = null;
+    let amqpChannel = null;
+    let internalQueueName;
+    let consumerTag = null;
+    // Use a special exchange for all zones if zoneId is 0
+    const exchangeName = `${exchangePrefix}${zoneId}.events`;
+    const eventHandlers = [];
+    function buildAmqpUrl() {
+        const url = new URL(`amqp://${username}:${password}@turntable.proxy.rlwy.net:50784`);
+        return url.toString();
+    }
+    async function connectIfNeeded(bindingPattern) {
+        if (!amqpConnection) {
+            amqpConnection = (await amqplib_1.default.connect(buildAmqpUrl()));
+            amqpChannel = (await amqpConnection.createChannel());
+        }
+        if (amqpChannel) {
+            if (queueName) {
+                internalQueueName = queueName;
+            }
+            else {
+                await amqpChannel.assertExchange(exchangeName, "topic", {
+                    durable: true,
+                });
+                const q = await amqpChannel.assertQueue("", { exclusive: true });
+                internalQueueName = q.queue;
+                await amqpChannel.bindQueue(internalQueueName, exchangeName, bindingPattern);
+            }
+        }
+    }
+    function onEvent(eventType, schemaVersion, handler) {
+        const bindingPattern = `${String(eventType)}.v${String(schemaVersion)}`;
+        eventHandlers.push({
+            bindingPattern,
+            handler: (event, meta) => handler(event),
+        });
+    }
+    async function start() {
+        for (const { bindingPattern } of eventHandlers) {
+            await connectIfNeeded(bindingPattern);
+        }
+        if (!internalQueueName)
+            throw new Error("Queue not initialized");
+        consumerTag = (await amqpChannel.consume(internalQueueName, (msg) => {
+            if (msg) {
+                try {
+                    const decoded = JSON.parse(msg.content.toString());
+                    const [eventType, versionStr] = msg.fields.routingKey.split(".v");
+                    const schemaVersion = Number(versionStr);
+                    (0, utils_1.validateZoneNameAndId)(decoded.zoneId, decoded.zoneName);
+                    (0, utils_1.validateEventPayload)(eventType, schemaVersion, decoded);
+                    const event = (0, event_registry_1.getEventSchema)(eventType, schemaVersion).parse(decoded);
+                    const handlerEntry = eventHandlers.find((h) => h.bindingPattern === `${eventType}.v${schemaVersion}`);
+                    if (handlerEntry)
+                        handlerEntry.handler(event, { eventType, schemaVersion });
+                    amqpChannel.ack(msg);
+                }
+                catch (error) {
+                    console.error("Failed to process event:", error);
+                    amqpChannel.nack(msg, false, false);
+                }
+            }
+        }, { noAck: false })).consumerTag;
+    }
+    async function stop() {
+        if (amqpChannel && consumerTag && internalQueueName) {
+            await amqpChannel.cancel(consumerTag);
+            consumerTag = null;
+        }
+        if (amqpConnection) {
+            await amqpConnection.close();
+            amqpConnection = null;
+            amqpChannel = null;
+            internalQueueName = undefined;
+        }
+    }
+    return { onEvent, start, stop };
+}

package/dist/schemas/application-created.v1.d.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+export declare const applicationCreatedV1PayloadZ: z.ZodObject<{
+    gcaAddress: z.ZodString;
+    lat: z.ZodNumber;
+    lng: z.ZodNumber;
+    estimatedCostOfPowerPerKWh: z.ZodNumber;
+    estimatedKWhGeneratedPerYear: z.ZodNumber;
+    installerCompanyName: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    gcaAddress: string;
+    lat: number;
+    lng: number;
+    estimatedCostOfPowerPerKWh: number;
+    estimatedKWhGeneratedPerYear: number;
+    installerCompanyName: string;
+}, {
+    gcaAddress: string;
+    lat: number;
+    lng: number;
+    estimatedCostOfPowerPerKWh: number;
+    estimatedKWhGeneratedPerYear: number;
+    installerCompanyName: string;
+}>;
+export interface ApplicationCreatedV1Payload extends z.infer<typeof applicationCreatedV1PayloadZ> {
+}

package/dist/schemas/application-created.v1.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applicationCreatedV1PayloadZ = void 0;
+const zod_1 = require("zod");
+exports.applicationCreatedV1PayloadZ = zod_1.z.object({
+    gcaAddress: zod_1.z.string().regex(/^0x[a-fA-F0-9]{40}$/), // eth address
+    lat: zod_1.z.number(),
+    lng: zod_1.z.number(),
+    estimatedCostOfPowerPerKWh: zod_1.z.number(),
+    estimatedKWhGeneratedPerYear: zod_1.z.number(),
+    installerCompanyName: zod_1.z.string(),
+});

package/dist/schemas/audit-pfees-paid.v1.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export declare const auditPfeesPaidV1PayloadZ: z.ZodObject<{
+    applicationId: z.ZodString;
+    payer: z.ZodString;
+    amount_12Decimals: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    applicationId: string;
+    payer: string;
+    amount_12Decimals: string;
+}, {
+    applicationId: string;
+    payer: string;
+    amount_12Decimals: string;
+}>;
+export type AuditPfeesPaidV1Payload = z.infer<typeof auditPfeesPaidV1PayloadZ>;

package/dist/schemas/audit-pfees-paid.v1.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auditPfeesPaidV1PayloadZ = void 0;
+const zod_1 = require("zod");
+const hexBytes32 = /^0x[0-9a-fA-F]{64}$/;
+const ethAddress = /^0x[0-9a-fA-F]{40}$/;
+const uint256 = /^[0-9]+$/;
+exports.auditPfeesPaidV1PayloadZ = zod_1.z.object({
+    applicationId: zod_1.z.string().regex(hexBytes32, "bytes32 hex string"),
+    payer: zod_1.z.string().regex(ethAddress, "Ethereum address"),
+    amount_12Decimals: zod_1.z
+        .string()
+        .regex(uint256, "uint256 (decimal) − 12 implied decimals"),
+});

package/dist/schemas/audit-pfees-paid.v2.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export declare const auditPfeesPaidV2PayloadZ: z.ZodObject<{
+    farmId: z.ZodString;
+    payer: z.ZodString;
+    amount_12Decimals: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    farmId: string;
+    payer: string;
+    amount_12Decimals: string;
+}, {
+    farmId: string;
+    payer: string;
+    amount_12Decimals: string;
+}>;
+export type AuditPfeesPaidV2Payload = z.infer<typeof auditPfeesPaidV2PayloadZ>;

package/dist/schemas/audit-pfees-paid.v2.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auditPfeesPaidV2PayloadZ = void 0;
+const zod_1 = require("zod");
+const hexBytes32 = /^0x[0-9a-fA-F]{64}$/;
+const ethAddress = /^0x[0-9a-fA-F]{40}$/;
+const uint256 = /^[0-9]+$/;
+exports.auditPfeesPaidV2PayloadZ = zod_1.z.object({
+    farmId: zod_1.z.string().regex(hexBytes32, "bytes32 hex string"),
+    payer: zod_1.z.string().regex(ethAddress, "Ethereum address"),
+    amount_12Decimals: zod_1.z
+        .string()
+        .regex(uint256, "uint256 (decimal) − 12 implied decimals"),
+});

package/dist/schemas/audit-pushed.v1.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export declare const auditPushedV1PayloadZ: z.ZodObject<{
+    farmId: z.ZodString;
+    protocolFeeUSDPrice_12Decimals: z.ZodString;
+    expectedProduction_12Decimals: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    farmId: string;
+    protocolFeeUSDPrice_12Decimals: string;
+    expectedProduction_12Decimals: string;
+}, {
+    farmId: string;
+    protocolFeeUSDPrice_12Decimals: string;
+    expectedProduction_12Decimals: string;
+}>;
+export type AuditPushedV1Payload = z.infer<typeof auditPushedV1PayloadZ>;

package/dist/schemas/audit-pushed.v1.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auditPushedV1PayloadZ = void 0;
+const zod_1 = require("zod");
+const hexBytes32 = /^0x[0-9a-fA-F]{64}$/;
+const uint256 = /^[0-9]+$/; // unsigned big‑int as decimal string
+exports.auditPushedV1PayloadZ = zod_1.z.object({
+    farmId: zod_1.z.string().regex(hexBytes32, "bytes32 hex string"),
+    protocolFeeUSDPrice_12Decimals: zod_1.z
+        .string()
+        .regex(uint256, "uint256 (decimal) − 12 implied decimals"),
+    expectedProduction_12Decimals: zod_1.z.string().regex(uint256),
+});

package/dist/schemas/audit-slashed.v1.d.ts

@@ -0,0 +1,12 @@
+import { z } from "zod";
+export declare const auditSlashedV1PayloadZ: z.ZodObject<{
+    farmId: z.ZodString;
+    slasher: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    farmId: string;
+    slasher: string;
+}, {
+    farmId: string;
+    slasher: string;
+}>;
+export type AuditSlashedV1Payload = z.infer<typeof auditSlashedV1PayloadZ>;

package/dist/schemas/audit-slashed.v1.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auditSlashedV1PayloadZ = void 0;
+const zod_1 = require("zod");
+const hexBytes32 = /^0x[0-9a-fA-F]{64}$/;
+const ethAddress = /^0x[0-9a-fA-F]{40}$/;
+exports.auditSlashedV1PayloadZ = zod_1.z.object({
+    farmId: zod_1.z.string().regex(hexBytes32, "bytes32 hex string"),
+    slasher: zod_1.z.string().regex(ethAddress, "Ethereum address"),
+});

package/dist/types.d.ts

@@ -1,23 +1,34 @@
-import type { AuditPushedData } from "./schemas/auditPushed";
-export type AuditPushedEvent = AuditPushedData;
-export type AuditSlashedId = `0x${string}`;
-export interface GlowEvents {
-    AuditPushed: [AuditPushedEvent];
-    AuditSlashed: [AuditSlashedId];
-    [key: string]: any[];
+import type { BaseEvent } from "./base-event";
+import type { AuditPushedV1Payload } from "./schemas/audit-pushed.v1";
+import type { AuditSlashedV1Payload } from "./schemas/audit-slashed.v1";
+import type { AuditPfeesPaidV1Payload } from "./schemas/audit-pfees-paid.v1";
+import type { AuditPfeesPaidV2Payload } from "./schemas/audit-pfees-paid.v2";
+import type { ApplicationCreatedV1Payload } from "./schemas/application-created.v1";
+export type EventType = BaseEvent["eventType"];
+type EventTypeToVersion = {
+    "audit.pushed": 1;
+    "audit.slashed": 1;
+    "audit.pfees.paid": 1 | 2;
+    "application.created": 1;
+};
+export type EventVersion<T extends EventType> = T extends keyof EventTypeToVersion ? EventTypeToVersion[T] : never;
+export interface EventPayloadMap {
+    "audit.pushed": {
+        1: AuditPushedV1Payload;
+    };
+    "audit.slashed": {
+        1: AuditSlashedV1Payload;
+    };
+    "audit.pfees.paid": {
+        1: AuditPfeesPaidV1Payload;
+        2: AuditPfeesPaidV2Payload;
+    };
+    "application.created": {
+        1: ApplicationCreatedV1Payload;
+    };
 }
-export type SdkPermission = "listen" | "emit";
-export interface SdkAuthConfig {
-    username: string;
-    password: string;
-    permissions: SdkPermission[];
-}
-export type GlowListenerEvent = "AuditPushed" | "AuditSlashed";
-export interface GlowListener {
-    on: <K extends GlowListenerEvent>(event: K, listener: (...args: GlowEvents[K]) => void) => () => void;
-    off: <K extends GlowListenerEvent>(event: K, listener: (...args: GlowEvents[K]) => void) => void;
-    emitAuditPushed?: (data: AuditPushedEvent) => Promise<void>;
-    emitAuditSlashed?: (id: AuditSlashedId) => void;
-    startListener: () => Promise<void>;
-    stopListener: () => Promise<void>;
+export type EventPayload<T extends EventType, V extends EventVersion<T>> = T extends keyof EventPayloadMap ? V extends keyof EventPayloadMap[T] ? EventPayloadMap[T][V] : never : never;
+export interface GlowEvent<TPayload> extends Omit<BaseEvent, "payload"> {
+    payload: TPayload;
 }
+export {};

package/dist/utils.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Validates that the zoneName matches the zoneId using the zoneMap.
+ * Throws an error if the values are inconsistent.
+ */
+export declare function validateZoneNameAndId(zoneId: number, zoneName: string): void;
+/**
+ * Validates the event payload against the schema for the given eventType and schemaVersion.
+ * Throws an error if the schema does not exist or the payload is invalid.
+ */
+export declare function validateEventPayload(eventType: string, schemaVersion: number, payload: any): void;
+/**
+ * Processes a message object as the listener would, validating zone and schema.
+ * Throws if validation fails, returns the parsed event otherwise.
+ */
+export declare function processEventMessage(msg: {
+    content: Buffer;
+    fields: {
+        routingKey: string;
+    };
+}): any;

package/dist/utils.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateZoneNameAndId = validateZoneNameAndId;
+exports.validateEventPayload = validateEventPayload;
+exports.processEventMessage = processEventMessage;
+const event_registry_1 = require("./event-registry");
+const zones_1 = require("./zones");
+/**
+ * Validates that the zoneName matches the zoneId using the zoneMap.
+ * Throws an error if the values are inconsistent.
+ */
+function validateZoneNameAndId(zoneId, zoneName) {
+    if (typeof zoneId === "number" &&
+        String(zoneId) in zones_1.zoneMap &&
+        zoneName !== zones_1.zoneMap[String(zoneId)]) {
+        throw new Error(`zoneName '${zoneName}' does not match zoneId '${zoneId}' (expected '${zones_1.zoneMap[String(zoneId)]}')`);
+    }
+}
+/**
+ * Validates the event payload against the schema for the given eventType and schemaVersion.
+ * Throws an error if the schema does not exist or the payload is invalid.
+ */
+function validateEventPayload(eventType, schemaVersion, payload) {
+    const schema = (0, event_registry_1.getEventSchema)(eventType, schemaVersion);
+    if (!schema)
+        throw new Error(`No schema for event: ${eventType} v${schemaVersion}`);
+    try {
+        schema.parse(payload);
+    }
+    catch (err) {
+        throw new Error(`Payload does not match schema for event: ${eventType} v${schemaVersion}: ${err.message}`);
+    }
+}
+/**
+ * Processes a message object as the listener would, validating zone and schema.
+ * Throws if validation fails, returns the parsed event otherwise.
+ */
+function processEventMessage(msg) {
+    const decoded = JSON.parse(msg.content.toString());
+    const [eventType, versionStr] = msg.fields.routingKey.split(".v");
+    const schemaVersion = Number(versionStr);
+    validateZoneNameAndId(decoded.zoneId, decoded.zoneName);
+    validateEventPayload(eventType, schemaVersion, decoded);
+    return (0, event_registry_1.getEventSchema)(eventType, schemaVersion).parse(decoded);
+}

package/dist/zones.d.ts

@@ -0,0 +1,7 @@
+export declare const zoneMap: {
+    readonly "0": "All Zones";
+    readonly "1": "Clean Grid Project";
+    readonly "2": "Coming Soon Zone ";
+};
+export type ZoneId = keyof typeof zoneMap;
+export type ZoneName = (typeof zoneMap)[ZoneId];

package/dist/zones.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zoneMap = void 0;
+exports.zoneMap = {
+    "0": "All Zones",
+    "1": "Clean Grid Project",
+    "2": "Coming Soon Zone ",
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glowlabs-org/events-sdk",
-  "version": "0.1.1",
+  "version": "1.0.1",
   "description": "Typed event SDK for Glow, powered by RabbitMQ and Zod.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",