@newhomestar/sdk 0.8.1 → 0.8.3

package/dist/events.d.ts

@@ -195,6 +195,93 @@ export declare function queueEvent(payload: QueueEventPayload): Promise<{
  * startOutboxRelay(db);
  */
 export declare function startOutboxRelay(db: any, options?: OutboxRelayOptions): ReturnType<typeof setInterval>;
+/**
+ * Options for processing an inbound webhook event.
+ */
+export interface WebhookEventOptions {
+    /**
+     * Unique idempotency key derived from provider-supplied data.
+     * Used as the UNIQUE constraint for deduplication.
+     *
+     * Recommended formats:
+     *   BambooHR:  `bamboohr:${webhookId}:${timestamp}`
+     *   Jira:      `jira:${webhookEvent.id}`
+     *   Generic:   SHA-256 hash of the raw payload body
+     */
+    idempotencyKey: string;
+    /**
+     * Event type string for classification and routing.
+     * e.g., "bamboohr.employee.updated", "jira.issue.created"
+     */
+    eventType: string;
+    /**
+     * Queue name for categorization (defaults to "webhook").
+     * Useful for filtering/querying inbound events by source.
+     */
+    queueName?: string;
+    /**
+     * Raw webhook payload — stored as-is in nova_inbound_events for audit.
+     */
+    payload: Record<string, unknown>;
+}
+/**
+ * Process an inbound webhook with full ACID guarantee.
+ *
+ * Atomically:
+ *   1. Checks idempotency (UNIQUE on idempotency_key in nova_inbound_events)
+ *   2. Inserts the raw payload into nova_inbound_events
+ *   3. Runs the handler callback (business logic + domain writes)
+ *   4. Writes outbox rows for any staged events
+ *   5. Marks the inbound event as 'processed'
+ *
+ * If the handler throws, the entire transaction rolls back — no partial
+ * writes, no phantom inbound events, no orphaned outbox rows.
+ *
+ * The caller should:
+ *   - Return HTTP 200 when status is 'processed' or 'duplicate'
+ *   - Return HTTP 500 when withWebhookEvent() throws (triggers provider retry)
+ *
+ * ## Idempotency
+ *
+ * The idempotency_key is a UNIQUE column on nova_inbound_events.
+ * If the same key is seen again:
+ *   - After successful processing: returns { status: 'duplicate' } immediately
+ *   - After a rolled-back failure: key doesn't exist, full retry occurs
+ *
+ * ## Outbox Integration
+ *
+ * The `emit` function passed to the handler stages outbox events.
+ * They are written to nova_outbound_events inside the same $transaction.
+ * Post-commit, they are relayed (fire-and-forget) by the integration's
+ * outbox relay (startHrisOutboxRelay or startOutboxRelay).
+ *
+ * @param db       - Prisma client (must have inboundEvent + eventOutbox models)
+ * @param opts     - Idempotency key, event type, payload
+ * @param handler  - Business logic callback; receives (tx, emit), runs inside $transaction
+ * @returns        - { status: 'processed', result } or { status: 'duplicate' }
+ * @throws         - On transaction failure (caller should return HTTP 500)
+ *
+ * @example
+ * ```typescript
+ * // In an integration's handleWebhook action:
+ * const { status } = await withWebhookEvent(db, {
+ *   idempotencyKey: `bamboohr:${webhookId}:${timestamp}`,
+ *   eventType: 'bamboohr.employee.updated',
+ *   queueName: 'bamboohr_webhooks',
+ *   payload: rawBody,
+ * }, async (tx, emit) => {
+ *   // All of this runs inside $transaction:
+ *   await tx.bambooEmployee.upsert({ ... });
+ *   emit('employee.upserted', buildEmployeeHrisEvent(emp).payload);
+ * });
+ *
+ * return { status }; // 200 for both 'processed' and 'duplicate'
+ * ```
+ */
+export declare function withWebhookEvent<R>(db: any, opts: WebhookEventOptions, handler: (tx: any, emit: ServiceEmitFn) => Promise<R>): Promise<{
+    status: 'processed' | 'duplicate';
+    result?: R;
+}>;
 /**
  * A single PGMQ message received from the Nova Events Service SSE stream.
  * Passed to InboundHandler and withInboundEvent().

package/dist/events.js

@@ -422,6 +422,166 @@ export function startOutboxRelay(db, options = {}) {
     }, intervalMs);
     return handle;
 }
+/**
+ * Process an inbound webhook with full ACID guarantee.
+ *
+ * Atomically:
+ *   1. Checks idempotency (UNIQUE on idempotency_key in nova_inbound_events)
+ *   2. Inserts the raw payload into nova_inbound_events
+ *   3. Runs the handler callback (business logic + domain writes)
+ *   4. Writes outbox rows for any staged events
+ *   5. Marks the inbound event as 'processed'
+ *
+ * If the handler throws, the entire transaction rolls back — no partial
+ * writes, no phantom inbound events, no orphaned outbox rows.
+ *
+ * The caller should:
+ *   - Return HTTP 200 when status is 'processed' or 'duplicate'
+ *   - Return HTTP 500 when withWebhookEvent() throws (triggers provider retry)
+ *
+ * ## Idempotency
+ *
+ * The idempotency_key is a UNIQUE column on nova_inbound_events.
+ * If the same key is seen again:
+ *   - After successful processing: returns { status: 'duplicate' } immediately
+ *   - After a rolled-back failure: key doesn't exist, full retry occurs
+ *
+ * ## Outbox Integration
+ *
+ * The `emit` function passed to the handler stages outbox events.
+ * They are written to nova_outbound_events inside the same $transaction.
+ * Post-commit, they are relayed (fire-and-forget) by the integration's
+ * outbox relay (startHrisOutboxRelay or startOutboxRelay).
+ *
+ * @param db       - Prisma client (must have inboundEvent + eventOutbox models)
+ * @param opts     - Idempotency key, event type, payload
+ * @param handler  - Business logic callback; receives (tx, emit), runs inside $transaction
+ * @returns        - { status: 'processed', result } or { status: 'duplicate' }
+ * @throws         - On transaction failure (caller should return HTTP 500)
+ *
+ * @example
+ * ```typescript
+ * // In an integration's handleWebhook action:
+ * const { status } = await withWebhookEvent(db, {
+ *   idempotencyKey: `bamboohr:${webhookId}:${timestamp}`,
+ *   eventType: 'bamboohr.employee.updated',
+ *   queueName: 'bamboohr_webhooks',
+ *   payload: rawBody,
+ * }, async (tx, emit) => {
+ *   // All of this runs inside $transaction:
+ *   await tx.bambooEmployee.upsert({ ... });
+ *   emit('employee.upserted', buildEmployeeHrisEvent(emp).payload);
+ * });
+ *
+ * return { status }; // 200 for both 'processed' and 'duplicate'
+ * ```
+ */
+export async function withWebhookEvent(db, opts, handler) {
+    const serviceSlug = process.env.NOVA_SERVICE_SLUG;
+    // Rows to relay post-commit
+    const outboxRows = [];
+    let result;
+    let isDuplicate = false;
+    try {
+        await db.$transaction(async (tx) => {
+            // ── 1. Idempotency check ──────────────────────────────────────────
+            const existing = await tx.inboundEvent.findUnique({
+                where: { idempotencyKey: opts.idempotencyKey },
+                select: { id: true, status: true },
+            });
+            if (existing) {
+                isDuplicate = true;
+                return; // Transaction commits as no-op
+            }
+            // ── 2. Insert inbound event (status: processing) ─────────────────
+            await tx.inboundEvent.create({
+                data: {
+                    idempotencyKey: opts.idempotencyKey,
+                    queueName: opts.queueName ?? 'webhook',
+                    eventType: opts.eventType,
+                    payload: opts.payload,
+                    status: 'processing',
+                    attempts: 1,
+                },
+            });
+            // ── 3. Run handler (business logic) ───────────────────────────────
+            const stagedEmits = [];
+            const emit = (topic, payload, idempotencyKey) => {
+                stagedEmits.push({ topic, payload, idempotencyKey });
+            };
+            result = await handler(tx, emit);
+            // ── 4. Write outbox rows for staged events ────────────────────────
+            for (const staged of stagedEmits) {
+                const fullPayload = {
+                    event_slug: staged.topic,
+                    source_service: serviceSlug ?? undefined,
+                    attributes: staged.payload,
+                    metadata: { source: 'webhook' },
+                };
+                const row = await tx.eventOutbox.create({
+                    data: {
+                        eventType: staged.topic,
+                        payload: fullPayload,
+                        ...(staged.idempotencyKey
+                            ? { idempotencyKey: staged.idempotencyKey }
+                            : {}),
+                    },
+                    select: { id: true, idempotencyKey: true },
+                });
+                outboxRows.push({
+                    id: row.id,
+                    idempotencyKey: row.idempotencyKey,
+                    payload: fullPayload,
+                });
+            }
+            // ── 5. Mark inbound event as processed ────────────────────────────
+            await tx.inboundEvent.update({
+                where: { idempotencyKey: opts.idempotencyKey },
+                data: { status: 'processed', processedAt: new Date() },
+            });
+        });
+    }
+    catch (err) {
+        // Transaction rolled back — record error best-effort (outside tx)
+        try {
+            await db.inboundEvent.upsert({
+                where: { idempotencyKey: opts.idempotencyKey },
+                create: {
+                    idempotencyKey: opts.idempotencyKey,
+                    queueName: opts.queueName ?? 'webhook',
+                    eventType: opts.eventType,
+                    payload: opts.payload,
+                    status: 'failed',
+                    error: String(err).slice(0, 500),
+                    attempts: 1,
+                },
+                update: {
+                    status: 'failed',
+                    error: String(err).slice(0, 500),
+                    attempts: { increment: 1 },
+                },
+            });
+        }
+        catch {
+            // Non-critical — the provider will retry on 500
+        }
+        // Re-throw so the HTTP handler returns 500
+        throw err;
+    }
+    if (isDuplicate)
+        return { status: 'duplicate' };
+    // ── Post-commit: relay outbox rows (fire-and-forget) ──────────────────
+    // The integration's startHrisOutboxRelay() or startOutboxRelay() is the
+    // safety net for any rows that fail immediate relay.
+    if (outboxRows.length > 0) {
+        const eventsUrl = process.env.NOVA_EVENTS_SERVICE_URL;
+        const serviceToken = process.env.NOVA_SERVICE_TOKEN;
+        if (eventsUrl && serviceToken) {
+            Promise.allSettled(outboxRows.map(row => _relayRow(db, row, eventsUrl, serviceToken))).catch(() => { });
+        }
+    }
+    return { status: 'processed', result };
+}
 // ── withInboundEvent ───────────────────────────────────────────────────────────
 /**
  * Atomically store an inbound PGMQ message + run the handler in one Prisma

package/dist/index.d.ts

@@ -357,13 +357,13 @@ export declare function runHttpServer<T extends WorkerDef>(def: T, opts?: HttpSe
 export declare function runDualMode<T extends WorkerDef>(def: T, opts?: {
     port?: number;
 }): void;
-export { withServiceEventOutbox, withEventOutbox, isIntegrationSync, queueEvent, logEvent, startOutboxRelay, startInboundConsumer, startPollConsumer, NovaEventsClient, } from './events.js';
-export type { QueueEventPayload, LogEventPayload, OutboxRelayOptions, ServiceEmitFn, InboundConsumerOptions, PollConsumerOptions, } from './events.js';
+export { withServiceEventOutbox, withEventOutbox, withWebhookEvent, isIntegrationSync, queueEvent, logEvent, startOutboxRelay, startInboundConsumer, startPollConsumer, NovaEventsClient, } from './events.js';
+export type { QueueEventPayload, LogEventPayload, OutboxRelayOptions, ServiceEmitFn, InboundConsumerOptions, PollConsumerOptions, WebhookEventOptions, } from './events.js';
 export type { ZodTypeAny as SchemaAny, ZodTypeAny };
 export { parseNovaSpec } from "./parseSpec.js";
 export type { NovaSpec } from "./parseSpec.js";
 export { defineIntegration, validateIntegration, integrationSchema, integrationEvent, integrationFunction, schema, event, IntegrationDefSchema, } from "./integration.js";
-export type { IntegrationDef, IntegrationSchemaDef, IntegrationEventDef, IntegrationFunctionDef, ValidationResult, SchemaType, ParamMeta, ParamIn, ParamUiType, SyncMappingDef, SyncMappingFieldDef, } from "./integration.js";
+export type { IntegrationDef, IntegrationSchemaDef, IntegrationEventDef, IntegrationFunctionDef, ValidationResult, SchemaType, ParamMeta, ParamIn, ParamUiType, SyncMappingDef, SyncMappingFieldDef, WebhookConfig, WebhookTypeDef, WebhookFieldDef, } from "./integration.js";
 export { parseIntegrationSpec, IntegrationSpecSchema } from "./integrationSpec.js";
 export type { IntegrationSpec } from "./integrationSpec.js";
 export type WebhookCapability = {

package/dist/index.js

@@ -897,7 +897,7 @@ export function runDualMode(def, opts = {}) {
 /*──────────────── Event Outbox (re-exports for convenience) ───────────────*/
 // Full API is also available via '@newhomestar/sdk/events' subpath.
 // These re-exports allow import { withServiceEventOutbox } from '@newhomestar/sdk'.
-export { withServiceEventOutbox, withEventOutbox, isIntegrationSync, queueEvent, logEvent, startOutboxRelay, startInboundConsumer, startPollConsumer, NovaEventsClient, } from './events.js';
+export { withServiceEventOutbox, withEventOutbox, withWebhookEvent, isIntegrationSync, queueEvent, logEvent, startOutboxRelay, startInboundConsumer, startPollConsumer, NovaEventsClient, } from './events.js';
 // YAML spec parsing utility
 export { parseNovaSpec } from "./parseSpec.js";
 // Integration definition API

package/dist/integration.d.ts

@@ -245,6 +245,88 @@ export interface SyncMappingDef {
     /** Per-field mapping rules */
     fields: SyncMappingFieldDef[];
 }
+/**
+ * A configuration field that users fill out when subscribing to a webhook type.
+ * Rendered as a dynamic form in the Odyssey UI.
+ */
+export interface WebhookFieldDef {
+    /** Field name (used as the key in the config JSON) */
+    name: string;
+    /** Human-readable label */
+    label: string;
+    /** Input widget type */
+    type: 'text' | 'select' | 'multiselect' | 'boolean' | 'url';
+    /** Whether this field is required */
+    required?: boolean;
+    /** Help text shown below the input */
+    description?: string;
+    /** Default value */
+    defaultValue?: unknown;
+    /** Options for select/multiselect fields */
+    options?: Array<{
+        label: string;
+        value: string;
+    }>;
+}
+/**
+ * Declares a category of inbound webhook the provider supports.
+ *
+ * This is metadata — it tells the platform:
+ * "This integration can receive webhooks of this type, producing these events."
+ *
+ * The actual webhook processing is handled by the integration's handler action
+ * using withWebhookEvent() for ACID compliance.
+ */
+export interface WebhookTypeDef {
+    /** Human-readable label shown in the UI (e.g., "Employee Changes") */
+    label: string;
+    /** Description shown in the UI */
+    description?: string;
+    /**
+     * Event types this webhook category produces.
+     * These are the event_slug values emitted via the outbox when
+     * webhooks of this type are processed.
+     * e.g., ["bamboohr.employee.created", "bamboohr.employee.updated"]
+     */
+    produces: string[];
+    /**
+     * How the provider authenticates/signs webhook payloads.
+     * Used for documentation and UI display (the integration itself
+     * verifies signatures in its handler action).
+     */
+    authentication?: {
+        /** Signature algorithm */
+        method: 'hmac_sha256' | 'hmac_sha1' | 'basic' | 'bearer' | 'none';
+        /** Header name containing the signature (e.g., "X-BambooHR-Signature") */
+        signatureHeader?: string;
+        /** Where the signing secret comes from */
+        secretSource?: 'platform_generated' | 'provider_assigned' | 'user_provided';
+    };
+    /**
+     * Configuration fields the user must fill when subscribing.
+     * Values are passed to the integration's create-webhook action.
+     */
+    fields?: WebhookFieldDef[];
+}
+/**
+ * Top-level webhook configuration for an integration.
+ * Declares the handler endpoint and available subscription types.
+ *
+ * Added to IntegrationDef as an optional `webhooks` property.
+ */
+export interface WebhookConfig {
+    /**
+     * Action slug that handles ALL inbound webhook payloads.
+     * Must be defined in the integration's `actions` map.
+     * The action should use withWebhookEvent() for ACID compliance.
+     */
+    handler: string;
+    /**
+     * Available webhook subscription types.
+     * Key = type slug (e.g., "employee_changes", "time_off")
+     */
+    types: Record<string, WebhookTypeDef>;
+}
 /**
  * Full integration definition — the single source of truth.
  *
@@ -338,6 +420,12 @@ export interface IntegrationDef {
      * ```
      */
     syncMappings?: Record<string, SyncMappingDef>;
+    /**
+     * Webhook configuration — declares inbound webhook types
+     * and how the platform should display/manage them in the UI.
+     * The integration's handler action does the actual processing.
+     */
+    webhooks?: WebhookConfig;
 }
 export declare const IntegrationDefSchema: z.ZodObject<{
     slug: z.ZodString;
@@ -441,6 +529,47 @@ export declare const IntegrationDefSchema: z.ZodObject<{
             transform: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
     }, z.core.$strip>>>;
+    webhooks: z.ZodOptional<z.ZodObject<{
+        handler: z.ZodString;
+        types: z.ZodRecord<z.ZodString, z.ZodObject<{
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            produces: z.ZodArray<z.ZodString>;
+            authentication: z.ZodOptional<z.ZodObject<{
+                method: z.ZodEnum<{
+                    none: "none";
+                    bearer: "bearer";
+                    basic: "basic";
+                    hmac_sha256: "hmac_sha256";
+                    hmac_sha1: "hmac_sha1";
+                }>;
+                signatureHeader: z.ZodOptional<z.ZodString>;
+                secretSource: z.ZodOptional<z.ZodEnum<{
+                    platform_generated: "platform_generated";
+                    provider_assigned: "provider_assigned";
+                    user_provided: "user_provided";
+                }>>;
+            }, z.core.$strip>>;
+            fields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                label: z.ZodString;
+                type: z.ZodEnum<{
+                    boolean: "boolean";
+                    text: "text";
+                    select: "select";
+                    multiselect: "multiselect";
+                    url: "url";
+                }>;
+                required: z.ZodOptional<z.ZodBoolean>;
+                description: z.ZodOptional<z.ZodString>;
+                defaultValue: z.ZodOptional<z.ZodUnknown>;
+                options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    label: z.ZodString;
+                    value: z.ZodString;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 /**
  * Result of validating an integration definition before build/push.

package/dist/integration.js

@@ -203,6 +203,31 @@ export const IntegrationDefSchema = z.object({
     events: z.record(z.string(), IntegrationEventDefSchema),
     functions: z.record(z.string(), IntegrationFunctionDefSchema),
     syncMappings: z.record(z.string(), SyncMappingDefSchema).optional(),
+    webhooks: z.object({
+        handler: z.string(),
+        types: z.record(z.string(), z.object({
+            label: z.string(),
+            description: z.string().optional(),
+            produces: z.array(z.string()).min(1),
+            authentication: z.object({
+                method: z.enum(['hmac_sha256', 'hmac_sha1', 'basic', 'bearer', 'none']),
+                signatureHeader: z.string().optional(),
+                secretSource: z.enum(['platform_generated', 'provider_assigned', 'user_provided']).optional(),
+            }).optional(),
+            fields: z.array(z.object({
+                name: z.string(),
+                label: z.string(),
+                type: z.enum(['text', 'select', 'multiselect', 'boolean', 'url']),
+                required: z.boolean().optional(),
+                description: z.string().optional(),
+                defaultValue: z.unknown().optional(),
+                options: z.array(z.object({
+                    label: z.string(),
+                    value: z.string(),
+                })).optional(),
+            })).optional(),
+        })),
+    }).optional(),
 });
 /**
  * Validate an integration definition before build or push.
@@ -425,5 +450,18 @@ export function defineIntegration(def) {
                 `which is not defined in schemas. Available schemas: ${Object.keys(def.schemas).join(', ')}`);
         }
     }
+    // ── Phase 7: Cross-validate webhook handler reference ──
+    if (def.webhooks) {
+        const handlerSlug = camelToSnake(def.webhooks.handler);
+        const fnSlugs = new Set(Object.keys(def.functions));
+        if (!fnSlugs.has(handlerSlug)) {
+            // Also check the raw action key before snake_case conversion
+            const actionKeys = new Set(Object.keys(def.actions));
+            if (!actionKeys.has(def.webhooks.handler)) {
+                throw new Error(`webhooks.handler '${def.webhooks.handler}' is not defined in actions. ` +
+                    `Available actions: ${Object.keys(def.actions).join(', ')}`);
+            }
+        }
+    }
     return def;
 }

package/dist/integrationSpec.d.ts

@@ -173,6 +173,19 @@ export declare const IntegrationSpecSchema: z.ZodObject<{
             requiredScopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
             category: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
+        webhookTypes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            slug: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            produces: z.ZodArray<z.ZodString>;
+            handler: z.ZodString;
+            authentication: z.ZodOptional<z.ZodObject<{
+                method: z.ZodString;
+                signatureHeader: z.ZodOptional<z.ZodString>;
+                secretSource: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            fields: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>;
     build: z.ZodOptional<z.ZodObject<{
         dockerfile: z.ZodString;

package/dist/integrationSpec.js

@@ -69,6 +69,19 @@ const CapabilitySchema = z.discriminatedUnion('type', [
     QueueCapabilitySchema,
     StreamCapabilitySchema,
 ]);
+const WebhookTypeSpecSchema = z.object({
+    slug: z.string(),
+    label: z.string(),
+    description: z.string().optional(),
+    produces: z.array(z.string()),
+    handler: z.string(),
+    authentication: z.object({
+        method: z.string(),
+        signatureHeader: z.string().optional(),
+        secretSource: z.string().optional(),
+    }).optional(),
+    fields: z.array(z.record(z.string(), z.unknown())).optional(),
+});
 export const IntegrationSpecSchema = z.object({
     apiVersion: z.string(),
     kind: z.literal('Integration'),
@@ -133,6 +146,7 @@ export const IntegrationSpecSchema = z.object({
         schemas: z.array(IntegrationSchemaSpecSchema).optional(),
         events: z.array(IntegrationEventSpecSchema).optional(),
         functions: z.array(IntegrationFunctionSpecSchema).optional(),
+        webhookTypes: z.array(WebhookTypeSpecSchema).optional(),
     }),
     build: z.object({
         dockerfile: z.string(),

package/package.json

@@ -1,58 +1,58 @@
-{
-  "name": "@newhomestar/sdk",
-  "version": "0.8.1",
-  "description": "Type-safe SDK for building Nova pipelines (workers & functions)",
-  "homepage": "https://github.com/newhomestar/nova-node-sdk#readme",
-  "bugs": {
-    "url": "https://github.com/newhomestar/nova-node-sdk/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/newhomestar/nova-node-sdk.git"
-  },
-  "license": "ISC",
-  "author": "Christian Gomez",
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    },
-    "./next": {
-      "import": "./dist/next.js",
-      "types": "./dist/next.d.ts"
-    },
-    "./events": {
-      "import": "./dist/events.js",
-      "types": "./dist/events.d.ts"
-    }
-  },
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "tsc"
-  },
-  "dependencies": {
-    "@openfga/sdk": "^0.9.0",
-    "@orpc/openapi": "1.7.4",
-    "@orpc/server": "1.7.4",
-    "@supabase/supabase-js": "^2.39.0",
-    "body-parser": "^1.20.2",
-    "dotenv": "^16.4.3",
-    "express": "^4.18.2",
-    "express-oauth2-jwt-bearer": "^1.7.4",
-    "undici": "^7.24.4",
-    "yaml": "^2.7.1"
-  },
-  "peerDependencies": {
-    "zod": ">=4.0.0"
-  },
-  "devDependencies": {
-    "@types/node": "^20.11.17",
-    "typescript": "^5.4.4",
-    "zod": "^4.3.0"
-  }
-}
+{
+  "name": "@newhomestar/sdk",
+  "version": "0.8.3",
+  "description": "Type-safe SDK for building Nova pipelines (workers & functions)",
+  "homepage": "https://github.com/newhomestar/nova-node-sdk#readme",
+  "bugs": {
+    "url": "https://github.com/newhomestar/nova-node-sdk/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/newhomestar/nova-node-sdk.git"
+  },
+  "license": "ISC",
+  "author": "Christian Gomez",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./next": {
+      "import": "./dist/next.js",
+      "types": "./dist/next.d.ts"
+    },
+    "./events": {
+      "import": "./dist/events.js",
+      "types": "./dist/events.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "dependencies": {
+    "@openfga/sdk": "^0.9.0",
+    "@orpc/openapi": "1.7.4",
+    "@orpc/server": "1.7.4",
+    "@supabase/supabase-js": "^2.39.0",
+    "body-parser": "^1.20.2",
+    "dotenv": "^16.4.3",
+    "express": "^4.18.2",
+    "express-oauth2-jwt-bearer": "^1.7.4",
+    "undici": "^7.24.4",
+    "yaml": "^2.7.1"
+  },
+  "peerDependencies": {
+    "zod": ">=4.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.17",
+    "typescript": "^5.4.4",
+    "zod": "^4.3.0"
+  }
+}