@everystack/events 0.2.2 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@everystack/events",
-  "version": "0.2.2",
+  "version": "0.3.1",
   "description": "PostgreSQL LISTEN/NOTIFY bridge for serverless — WebSocket fan-out + Lambda invocation",
   "license": "AGPL-3.0-only",
   "author": "Scalable Technology, Inc. <licensing@scalable.technology>",
@@ -37,6 +37,10 @@
       "types": "./src/schema.ts",
       "default": "./src/schema.ts"
     },
+    "./models": {
+      "types": "./src/models/index.ts",
+      "default": "./src/models/index.ts"
+    },
     "./client": {
       "types": "./src/client/index.ts",
       "default": "./src/client/index.ts"
@@ -50,6 +54,9 @@
       "default": "./src/listener.ts"
     }
   },
+  "dependencies": {
+    "@everystack/model": "0.3.3"
+  },
   "peerDependencies": {
     "@aws-sdk/client-apigatewaymanagementapi": "3.1053.0",
     "@aws-sdk/client-cloudfront-keyvaluestore": "3.1053.0",
@@ -92,7 +99,7 @@
     "react": "19.2.6",
     "ts-jest": "29.4.9",
     "typescript": "5.9.3",
-    "@everystack/auth": "0.2.6"
+    "@everystack/auth": "0.3.1"
   },
   "scripts": {
     "test": "jest",

package/src/models/event-action.ts

@@ -0,0 +1,46 @@
+/**
+ * ops.event_actions — data-driven event routing. Rules the listener loads (and caches,
+ * reloading on a `_event_actions` NOTIFY) to dispatch actions when a DB mutation fires.
+ * Admin-configurable, no redeploy.
+ *
+ * The v3 Model that owns this table's schema AND its authorization. The drizzle runtime
+ * table (`../schema`) derives from it via `toDrizzleTable`, and `db:generate` reads it to
+ * emit the DDL + RLS + grants — the events package owns its table end to end. The notify
+ * functions + triggers it pairs with are package SQL (`../triggers`), contributed through the
+ * events Module's `functions`, not modeled.
+ *
+ * Authz:
+ *  - `writtenBy: 'worker'` — the listener reads it on the owner connection, so it must keep
+ *    the owner's RLS bypass: ENABLE-not-FORCE. (Admin configures it through the admin path.)
+ *  - `can('manage', { role: 'admin' })` — admin gets CRUD + the `event_actions_admin` policy.
+ *  - `private: true` — reached through the listener + the admin path, never the generic API.
+ */
+
+import { defineModel, field, can, index } from '@everystack/model';
+
+export const EventAction = defineModel('event_actions', {
+  schema: 'ops',
+  writtenBy: 'worker',
+  private: true,
+  fields: {
+    id: field.uuid().primaryKey().defaultRandom(),
+    tenantId: field.uuid().nullable(), // NULL = platform-wide, non-NULL = tenant-scoped
+    name: field.text().notNull(),
+    schemaName: field.text().notNull().default('public'),
+    tableName: field.text().notNull(),
+    operation: field.text().notNull(), // 'insert' | 'update' | 'delete' | '*'
+    actionType: field.text().notNull(), // 'rpc' | 'job' | 'cache_purge' | 'webhook'
+    config: field.jsonb().notNull().default('{}'),
+    filter: field.jsonb().nullable(),
+    enabled: field.boolean().notNull().default(true),
+    priority: field.integer().notNull().default(0),
+    createdAt: field.timestamptz().defaultNow(),
+    updatedAt: field.timestamptz().defaultNow(),
+  },
+  constraints: [
+    index('schemaName', 'tableName', 'operation', 'enabled'),
+    index('tenantId'),
+    index('enabled'),
+  ],
+  abilities: [can('manage', { role: 'admin' })],
+});

package/src/models/index.ts

@@ -0,0 +1,26 @@
+/**
+ * Events' package-owned models + Module. A consuming app composes `eventModule` so
+ * `db:generate` emits ops.event_actions (schema + authz) plus the notify functions/triggers.
+ *
+ * The trigger ATTACHMENT (which app tables emit events) is the app's choice, so it is NOT in
+ * this module — the app contributes `generateTriggerSQL([...its tables])` in its own module.
+ * This module ships the table + the `event_actions` self-notify function/trigger.
+ */
+
+import { defineModule } from '@everystack/model';
+import { EventAction } from './event-action';
+import { generateEventActionsTriggerSQL } from '../triggers';
+
+export { EventAction } from './event-action';
+
+/** All events-owned models, for the app to spread into its db:generate model list. */
+export const eventModels = [EventAction];
+
+/**
+ * The events Module: the event_actions table + its self-notify function/trigger. The
+ * per-app-table event triggers are the app's contribution (`generateTriggerSQL(tables)`).
+ */
+export const eventModule = defineModule({
+  models: eventModels,
+  functions: generateEventActionsTriggerSQL,
+});

package/src/schema.ts

@@ -21,8 +21,9 @@ import {
   index,
   uniqueIndex,
   jsonb,
-  boolean,
 } from 'drizzle-orm/pg-core';
+import { toDrizzleTable } from '@everystack/model/drizzle';
+import { EventAction } from './models/event-action';
 
 const authSchema = pgSchema('auth');
 
@@ -101,40 +102,9 @@ export const sessions = authSchema.table(
 // EVENT ACTIONS (ops.event_actions — data-driven event routing)
 // =============================================================================
 
-const opsSchema = pgSchema('ops');
-
 /**
- * Event actions define what happens when a database event occurs.
- * Loaded by the listener on startup, cached in memory, reloaded on change.
- *
- * tenant_id: NULL = platform-wide, non-NULL = tenant-scoped
- * operation: 'insert' | 'update' | 'delete' | '*'
- * action_type: 'rpc' | 'job' | 'cache_purge' | 'webhook'
- * config: action-specific JSONB (discriminated union keyed by action_type)
- * filter: optional row conditions for conditional firing
+ * Event actions define what happens when a database event occurs. DERIVED from the
+ * package-owned Model (`./models/event-action`) — edit the Model, not this. The runtime
+ * drizzle table the listener queries.
  */
-export const eventActions = opsSchema.table(
-  'event_actions',
-  {
-    id: uuid('id').primaryKey().defaultRandom(),
-    tenantId: uuid('tenant_id'),
-    name: text('name').notNull(),
-    schemaName: text('schema_name').notNull().default('public'),
-    tableName: text('table_name').notNull(),
-    operation: text('operation').notNull(),
-    actionType: text('action_type').notNull(),
-    config: jsonb('config').notNull().default('{}'),
-    filter: jsonb('filter'),
-    enabled: boolean('enabled').notNull().default(true),
-    priority: integer('priority').notNull().default(0),
-    createdAt: timestamp('created_at', { withTimezone: true }).defaultNow(),
-    updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow(),
-  },
-  (table) => ({
-    lookupIdx: index('event_actions_lookup_idx').on(
-      table.schemaName, table.tableName, table.operation, table.enabled
-    ),
-    tenantIdx: index('event_actions_tenant_idx').on(table.tenantId),
-    enabledIdx: index('event_actions_enabled_idx').on(table.enabled),
-  })
-);
+export const eventActions = toDrizzleTable(EventAction);

package/src/triggers.ts

@@ -1,13 +1,23 @@
 const NOTIFY_FUNCTION = `\
 CREATE OR REPLACE FUNCTION everystack_notify() RETURNS trigger AS $$
+DECLARE
+  row_id text;
 BEGIN
+  -- A composite-key table (e.g. likes (user_id, post_id), follows (follower_id, following_id))
+  -- has no \`id\` column, so NEW.id raises undefined_column — emit a NULL id rather than fail
+  -- the whole write. Without this guard, any INSERT/UPDATE/DELETE on such a table errors.
+  BEGIN
+    row_id := COALESCE(NEW.id, OLD.id);
+  EXCEPTION WHEN undefined_column THEN
+    row_id := NULL;
+  END;
   PERFORM pg_notify(
     'events',
     json_build_object(
       'schema', TG_TABLE_SCHEMA,
       'table', TG_TABLE_NAME,
       'op', lower(TG_OP),
-      'id', COALESCE(NEW.id, OLD.id)
+      'id', row_id
     )::text
   );
   RETURN COALESCE(NEW, OLD);