@engine9/schemas 1.9.0

package/.eslintignore

@@ -0,0 +1 @@
+node_modules

package/.prettierrc

@@ -0,0 +1,7 @@
+{
+  "semi": true,
+  "singleQuote": true,
+  "tabWidth": 2,
+  "printWidth": 120,
+  "trailingComma": "none"
+}

package/AGENTS.md

@@ -0,0 +1,10 @@
+# Agent guide — `@engine9/schemas`
+
+## License
+
+`@engine9/schemas` is MIT licensed. See [LICENSE](LICENSE). Use, copy,
+modify, and distribute this code as-is. No further permission is required.
+
+`@engine9/core`, `@engine9/id`, `demo-festival`, and `demo-id` are also MIT.
+The private repositories `delegate` and `server` are not open source. Do not
+copy code from those repositories under this license.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Engine9
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,33 @@
+# @engine9/schemas
+
+The engine9 standard schemas: shared tables, inbound transforms, searches, and segments used by core and by plugins. Each directory with an `index.js` is a **schema plugin** (`@engine9/schemas/person_email`, `@engine9/schemas/transaction/core`, …). A schema plugin's table definitions are its `schema.js`. Building on these schema plugins lets other plugins share common tools and features while adding their own functionality.
+
+This package was published as `@engine9/interfaces` through 1.8.1. `@engine9/core` still reads `@engine9/interfaces/...` paths stored before the rename; `PluginWorker.migratePackageRename` rewrites them.
+
+This package is [MIT licensed](./LICENSE). Use, copy, modify, and distribute
+this code as-is.
+
+## Documentation
+
+Each schema plugin is documented in its own `README.md`. That file is the human-readable contract: what the schema plugin is for, the data model, inbound/outbound behavior, search, **predefined segments**, and UI. Keep implementation details in code comments; keep audience and membership rules in the README. Dashboards live on `@engine9/plugins/reports/<area>`, not in this package.
+
+Schema plugins with predefined segments:
+
+- [`person_email`](person_email/README.md) — Email Subscribers
+- [`person_phone`](person_phone/README.md) — Textable People
+- [`transaction/core`](transaction/core/README.md) — Customers
+- [`channels/email`](channels/email/README.md) — rolling-window email openers and clickers
+
+See [`skills/create-engine9-plugin/SKILL.md`](../skills/create-engine9-plugin/SKILL.md) for the README layout.
+
+## Conventions
+
+- **Plugin uniqueness:** `SchemaWorker.install` reuses an existing `plugin` row when the path is unique: `metadata.unique` if set, otherwise `@engine9/schemas/*` (except `person_custom`, which is `unique: false`). Native plugins that set `unique: true` behave the same. Third-party plugins and `person_custom` may have more than one instance per path; pass `id` to update an existing non-unique row.
+
+- **Public module surface:** Export only the standard building blocks documented in [`skills/create-engine9-plugin/SKILL.md`](../skills/create-engine9-plugin/SKILL.md): for example `metadata`, optional `schema`, `transforms`, `search`, `segments`, `metrics`, and the default object that aggregates them. Do **not** export `reports` from schema plugins — dashboards belong on `@engine9/plugins/reports/<area>`. Do **not** export ad hoc hooks (such as custom install helpers or segment–plugin wiring) from schema plugins; the server is responsible for any special install-time behavior tied to a specific schema plugin path.
+
+- **Segments, universes, and `plugin_id`:** Saved segments use `segment.plugin_id` = the schema plugin (or plugin) that **owns the definition**. A definition’s **`universe`** describes the span of source data searched across; input EQL entries select timeline stores, while person/table entries can restrict eligible people. Explicit `pluginId` values inside `search` options may narrow that span further, so a segment can evaluate data tied to other deployed plugins without changing its owning `plugin_id`. Export bundles use the same universe vocabulary for table and input-file artifacts.
+
+## License
+
+[MIT](./LICENSE). Use, copy, modify, and distribute this code as-is.

package/channels/email/README.md

@@ -0,0 +1,83 @@
+# Email Channel Schema Plugin
+
+The `@engine9/schemas/channels/email` plugin defines email-channel search and engagement segments. It does not create its own tables. Segment builds read `global_message`, `input`, and `timeline` rows produced by email message plugins.
+
+It depends on `@engine9/schemas/person` because membership is always a set of people.
+
+## Search
+
+`emailEngagement` finds people who opened or clicked email in a rolling window.
+
+| Option | Meaning |
+| --- | --- |
+| `windowDays` | Rolling window: `30`, `60`, or `90` days |
+| `timelineEntryType` | `EMAIL_OPEN` or `EMAIL_CLICK` |
+| `pluginId` | Optional. When set, only that plugin's inputs are included. When empty, scope comes from the segment universe instead |
+
+The search looks at `timeline` rows whose `entry_type_id` matches the engagement type and whose `ts` is in the window. It always joins `timeline.input_id = input.id`, so only timeline entries for inputs present in the build are counted.
+
+## Segments
+
+Predefined audiences shipped with this schema plugin. On install, each key becomes a `segment` row whose definition path is `@engine9/schemas/channels/email:segments:<key>`.
+
+Every segment here uses the same **universe** and the `emailEngagement` search. The universe and the search do different jobs, and both are required:
+
+- **Universe** chooses *which email sends* can contribute entries: messages on the email channel published in the last **90 days** (`global_message.channel = 'email'` and `publish_date` within 90 days). Those message ids become the `input` rows for the build.
+- **Search** chooses *which people* from those sends belong in the audience: a recent open or click on the timeline, inside the segment's rolling window.
+
+An open or click on a message published more than 90 days ago does not count, even if the entry itself is recent. `pluginId` is left empty so the universe, not a hardcoded plugin, decides which message stores are scanned.
+
+### 30-day email openers
+
+| | |
+| --- | --- |
+| **Key** | `email_openers_30d` |
+| **Definition path** | `@engine9/schemas/channels/email:segments:email_openers_30d` |
+| **Who is included** | People with an `EMAIL_OPEN` on a universe email in the last 30 days |
+| **Who is excluded** | People with no open in that window, or whose only opens are on messages outside the 90-day published universe |
+
+### 60-day email openers
+
+| | |
+| --- | --- |
+| **Key** | `email_openers_60d` |
+| **Definition path** | `@engine9/schemas/channels/email:segments:email_openers_60d` |
+| **Who is included** | People with an `EMAIL_OPEN` on a universe email in the last 60 days |
+
+### 90-day email openers
+
+| | |
+| --- | --- |
+| **Key** | `email_openers_90d` |
+| **Definition path** | `@engine9/schemas/channels/email:segments:email_openers_90d` |
+| **Who is included** | People with an `EMAIL_OPEN` on a universe email in the last 90 days |
+
+### 30-day email clickers
+
+| | |
+| --- | --- |
+| **Key** | `email_clickers_30d` |
+| **Definition path** | `@engine9/schemas/channels/email:segments:email_clickers_30d` |
+| **Who is included** | People with an `EMAIL_CLICK` on a universe email in the last 30 days |
+| **Who is excluded** | People who only opened (and did not click), or whose only clicks are outside the window or universe |
+
+### 60-day email clickers
+
+| | |
+| --- | --- |
+| **Key** | `email_clickers_60d` |
+| **Definition path** | `@engine9/schemas/channels/email:segments:email_clickers_60d` |
+| **Who is included** | People with an `EMAIL_CLICK` on a universe email in the last 60 days |
+
+### 90-day email clickers
+
+| | |
+| --- | --- |
+| **Key** | `email_clickers_90d` |
+| **Definition path** | `@engine9/schemas/channels/email:segments:email_clickers_90d` |
+| **Who is included** | People with an `EMAIL_CLICK` on a universe email in the last 90 days |
+
+## Reports and UI
+
+This schema plugin does not ship reports. Email engagement and fundraising dashboards live on `@engine9/plugins/reports/messaging` (`email`, `email_transactions`). See [`plugins/reports/messaging/README.md`](../../../plugins/reports/messaging/README.md).
+

package/channels/email/index.js

@@ -0,0 +1,22 @@
+import search from './search.js';
+import segments, { personSegmentTableName, universeEmailPublished90d } from './segments.js';
+
+const metadata = {
+  name: '@engine9/schemas/channels/email',
+  dependencies: {
+    '@engine9/schemas/person': '>=1.9.0'
+  }
+};
+
+export { metadata };
+export { search };
+export { segments };
+export { personSegmentTableName };
+export { universeEmailPublished90d };
+export default {
+  metadata,
+  search,
+  segments,
+  personSegmentTableName,
+  universeEmailPublished90d
+};

package/channels/email/search.js

@@ -0,0 +1,86 @@
+import { TIMELINE_ENTRY_TYPES } from '@engine9/input-tools';
+
+/**
+ * Build EQL for email engagement (opens / clicks) within a rolling window.
+ *
+ * The search always joins `timeline` → `input` on `timeline.input_id = input.id`.
+ * During a segment build the DuckDB `input` table is populated exclusively with
+ * the input ids discovered by the segment's `universe` entry (e.g.
+ * `universeEmailPublished90d`), so the join scopes results to the universe even
+ * when no explicit `pluginId` is provided.  When `pluginId` IS set, an additional
+ * `input.plugin_id` filter is applied.
+ */
+function buildEmailEngagementEql({ pluginId, windowDays, timelineEntryType }) {
+  const typeId = TIMELINE_ENTRY_TYPES[timelineEntryType];
+  if (typeof typeId !== 'number') {
+    throw new Error(`Invalid timelineEntryType for email engagement: ${timelineEntryType}`);
+  }
+  const days = parseInt(windowDays, 10);
+  if (!Number.isFinite(days) || days <= 0) {
+    throw new Error('windowDays must be a positive number');
+  }
+  const label =
+    timelineEntryType === 'EMAIL_OPEN'
+      ? 'email open'
+      : timelineEntryType === 'EMAIL_CLICK'
+        ? 'email click'
+        : timelineEntryType;
+  const hasPlugin = pluginId != null && String(pluginId).trim() !== '';
+  const conditions = [
+    { eql: `timeline.entry_type_id=${typeId}` },
+    { eql: `timeline.ts >= date_sub(now(), interval ${days} day)` }
+  ];
+  if (hasPlugin) {
+    const safePluginId = String(pluginId).replace(/'/g, "''");
+    conditions.push({ eql: `input.plugin_id='${safePluginId}'` });
+  }
+  const text = hasPlugin
+    ? `Has a ${label} from plugin ${String(pluginId)} in the last ${days} days`
+    : `Has a ${label} in the last ${days} days (scoped to universe inputs)`;
+  return {
+    text,
+    eql: {
+      table: 'timeline',
+      joins: [
+        {
+          table: 'input',
+          join_eql: 'timeline.input_id=input.id'
+        }
+      ],
+      columns: ['person_id'],
+      conditions
+    }
+  };
+}
+
+export const emailEngagement = {
+  title: 'Email engagement (opens / clicks)',
+  form: {
+    title: 'Email engagement (opens / clicks)',
+    type: 'object',
+    properties: {
+      pluginId: {
+        title: 'Plugin ID',
+        type: 'string'
+      },
+      windowDays: {
+        title: 'Window (days)',
+        type: 'number',
+        enum: [30, 60, 90]
+      },
+      timelineEntryType: {
+        title: 'Engagement type',
+        type: 'string',
+        enum: ['EMAIL_OPEN', 'EMAIL_CLICK']
+      }
+    },
+    required: ['windowDays', 'timelineEntryType']
+  },
+  optionsToEQL(options) {
+    return buildEmailEngagementEql(options);
+  }
+};
+
+export default {
+  emailEngagement
+};

package/channels/email/segments.js

@@ -0,0 +1,81 @@
+const SEGMENT_SEARCH_PATH = '@engine9/schemas/channels/email:search:emailEngagement';
+
+/**
+ * EQL over the message table: rows published in the last 90 days on the email channel.
+ * `message.id` is the input_id used when the message is loaded as an input; stores are
+ * scanned for timeline parquet.
+ *
+ * During a segment build the input ids returned here are copied into the DuckDB `input`
+ * table.  The search EQL (see `emailEngagement` in `search.js`) always joins
+ * `timeline.input_id = input.id`, so only timeline rows whose input is in **this**
+ * universe are considered — even when `pluginId` is empty.  This means:
+ *
+ * - The **universe** controls *which* message/input stores supply timeline data.
+ * - The **search** applies time-window and entry-type filters *within* that scope.
+ *
+ * Both layers are required for correct segment membership counts.
+ */
+export const universeEmailPublished90d = {
+  type: 'inputs',
+  eql: {
+    table: 'global_message',
+    columns: [{ column: 'id', name: 'input_id' }],
+    conditions: [{ eql: `channel='email'` }, { eql: `publish_date >= date_sub(now(), interval 90 day)` }]
+  }
+};
+
+/** Materialized membership table: person_segment_<table_prefix>_<segment_name> (trailing _ on prefix trimmed to avoid __). */
+export function personSegmentTableName(tablePrefix, segmentName) {
+  const pre = String(tablePrefix ?? '')
+    .trim()
+    .replace(/_+$/u, '');
+  return `person_segment_${pre}_${segmentName}`;
+}
+
+/**
+ * Build a segment definition for email engagement (opens or clicks).
+ *
+ * `pluginId` is left empty intentionally: the search handler in `search.js`
+ * always joins `timeline` → `input`, and the segment `universe` determines
+ * which input rows are present in DuckDB.  This scopes the time-window query
+ * to the correct set of message inputs without hard-coding a plugin id.
+ */
+function emailEngagementSegment(name, windowDays, timelineEntryType) {
+  return {
+    name,
+    universe: [universeEmailPublished90d],
+    search: {
+      and: [
+        {
+          path: SEGMENT_SEARCH_PATH,
+          options: {
+            pluginId: '',
+            windowDays,
+            timelineEntryType
+          }
+        }
+      ]
+    }
+  };
+}
+
+/**
+ * Rolling-window engagement segments.  `pluginId` is empty so scope follows the
+ * segment `universe` (the `input` table join in the search EQL restricts to
+ * universe-provided message input ids).
+ */
+export const email_openers_30d = emailEngagementSegment('30-day email openers', 30, 'EMAIL_OPEN');
+export const email_openers_60d = emailEngagementSegment('60-day email openers', 60, 'EMAIL_OPEN');
+export const email_openers_90d = emailEngagementSegment('90-day email openers', 90, 'EMAIL_OPEN');
+export const email_clickers_30d = emailEngagementSegment('30-day email clickers', 30, 'EMAIL_CLICK');
+export const email_clickers_60d = emailEngagementSegment('60-day email clickers', 60, 'EMAIL_CLICK');
+export const email_clickers_90d = emailEngagementSegment('90-day email clickers', 90, 'EMAIL_CLICK');
+
+export default {
+  email_openers_30d,
+  email_openers_60d,
+  email_openers_90d,
+  email_clickers_30d,
+  email_clickers_60d,
+  email_clickers_90d
+};

package/eslint.config.js

@@ -0,0 +1,21 @@
+import js from '@eslint/js';
+import nodePlugin from 'eslint-plugin-n';
+
+export default [
+  nodePlugin.configs['flat/recommended-module'],
+  js.configs.recommended,
+  {
+    rules: {
+      'n/exports-style': ['error', 'module.exports'],
+      'n/no-unsupported-features/node-builtins': 'off', // fetch and a lot of good things are here
+      'n/no-extraneous-require': 'off', // a few libraries use this
+      'n/no-extraneous-import': 'off', // a few libraries use this
+      'n/no-unpublished-require': 'off', // a few local calls use this
+      'n/no-unpublished-import': 'off' // devDependencies and local imports
+    }
+  },
+  {
+    files: ['**/*.js'],
+    languageOptions: { sourceType: 'module' }
+  }
+];

package/event/README.md

@@ -0,0 +1,79 @@
+# Event Schema Plugin
+
+`@engine9/schemas/event` is the shared calendar-style event contract: an `event` row plus `person_event` RSVP / attendance links. Install on accounts that need events; it is not part of the standard stack.
+
+Depends on `@engine9/schemas/person` because every `person_event` row belongs to a person through `person_id`.
+
+## Data Model
+
+### `event`
+
+Minimum useful calendar event. Names track common iCal `VEVENT` properties (RFC 5545) without recurrence or structured geo.
+
+| Field | Type | iCal | Description |
+| --- | --- | --- | --- |
+| `id` | `id_uuid` | `UID` | Event id. |
+| `name` | `string` | `SUMMARY` | Short title (required). |
+| `description` | `string` | `DESCRIPTION` | Longer body / notes. |
+| `start` | `datetime` | `DTSTART` | Start instant (store UTC; display with `timezone`). |
+| `end` | `datetime` | `DTEND` | End instant; null when open-ended or unknown. |
+| `timezone` | `string` | `TZID` | IANA zone for display, e.g. `America/New_York`. |
+| `all_day` | `boolean` | date vs date-time | True when the event is a calendar day without a clock time. Defaults to `false`. |
+| `location` | `string` | `LOCATION` | Venue or place text. |
+| `url` | `string` | `URL` | Canonical or ticket link. |
+| `status` | `string` | `STATUS` | `Tentative`, `Confirmed` (default), or `Cancelled`. |
+| `source_input_id` | `foreign_uuid` | — | Input that created or owns the row. |
+| `created_at` / `modified_at` | timestamps | `CREATED` / `LAST-MODIFIED` | Row lifecycle. |
+
+Indexes: primary `id`; `start`, `end`, `status`, `source_input_id`.
+
+**Intentionally omitted (v1):** `RRULE` / recurrence, `GEO`, `ORGANIZER`, remote event ids, `CATEGORIES`, `CLASS`, `TRANSP`, `SEQUENCE`. Plugins can keep those in their own tables or remote payloads.
+
+### `person_event`
+
+One person linked to one event for invite / RSVP / attendance.
+
+| Field | Type | iCal | Description |
+| --- | --- | --- | --- |
+| `id` | `id` | — | Row id. |
+| `event_id` | `foreign_uuid` | — | Parent event. |
+| `person_id` | `person_id` | — | Linked person. |
+| `response` | `string` | `ATTENDEE` `PARTSTAT` | `Invited` (default, ≈ `NEEDS-ACTION`), `Accepted`, `Declined`, `Tentative`, or `Attended` (post-event check-in beyond iCal). |
+| `role` | `string` | `ATTENDEE` `ROLE` | `Required` (default), `Optional`, `Chair`, or `Non-Participant`. |
+| `responded_at` | `datetime` | — | When the person last set `response`. |
+| `source_input_id` | `foreign_uuid` | — | Provenance input when imported. |
+| `created_at` / `modified_at` | timestamps | — | Row lifecycle. |
+
+Indexes: primary `id`; `person_id`, `event_id`, `response`; unique `(event_id, person_id)`.
+
+**Attend / Decline:** upsert `person_event` with `response` `Accepted` or `Declined` (and set `responded_at`). Use `Tentative` for maybe, `Attended` after check-in, `Invited` until they answer.
+
+## Inbound Behavior
+
+None in this package. Native event / calendar plugins should upsert `event` and `person_event` (and may later contribute inbound transforms).
+
+## Outbound Behavior
+
+None.
+
+## Search
+
+| Key | Path | Purpose |
+| --- | --- | --- |
+| `responses` | `@engine9/schemas/event:search:responses` | Filter people by `person_event.response` and optional `eventId`. |
+
+## Segments
+
+None.
+
+## Metrics
+
+None.
+
+## Reports and UI
+
+None on this schema plugin. Dashboards belong on `@engine9/plugins/reports/<area>` if needed later.
+
+## Settings
+
+None.

package/event/index.js

@@ -0,0 +1,17 @@
+import schema from './schema.js';
+import search from './search.js';
+
+const metadata = {
+  name: '@engine9/schemas/event',
+  dependencies: {
+    '@engine9/schemas/person': '>=1.9.0'
+  },
+  schemas: ['schema.js']
+};
+
+export { metadata, schema, search };
+export default {
+  metadata,
+  schema,
+  search
+};

package/event/schema.js

@@ -0,0 +1,111 @@
+/**
+ * Broad calendar-style event + person RSVP.
+ * Field names align with common iCal VEVENT / ATTENDEE concepts (RFC 5545)
+ * without requiring recurrence (RRULE), GEO, or full ATTENDEE parameter sets.
+ */
+export const tables = [
+  {
+    name: 'event',
+    columns: {
+      id: 'id_uuid',
+      name: {
+        type: 'string',
+        nullable: false,
+        description: 'Short title (iCal SUMMARY)'
+      },
+      description: {
+        type: 'string',
+        description: 'Longer body / notes (iCal DESCRIPTION)'
+      },
+      start: {
+        type: 'datetime',
+        nullable: false,
+        description: 'Event start (iCal DTSTART); store UTC, interpret with timezone'
+      },
+      end: {
+        type: 'datetime',
+        description: 'Event end (iCal DTEND); null when open-ended or duration unknown'
+      },
+      timezone: {
+        type: 'string',
+        description: 'IANA timezone for start/end display (iCal TZID), e.g. America/New_York'
+      },
+      all_day: {
+        type: 'boolean',
+        nullable: false,
+        default_value: false,
+        description: 'True when start/end are calendar dates without a clock time'
+      },
+      location: {
+        type: 'string',
+        description: 'Human-readable place or venue (iCal LOCATION)'
+      },
+      url: {
+        type: 'string',
+        description: 'Canonical or ticket URL (iCal URL)'
+      },
+      status: {
+        type: 'string',
+        nullable: false,
+        default_value: 'Confirmed',
+        values: ['Tentative', 'Confirmed', 'Cancelled'],
+        description: 'Lifecycle of the event itself (iCal STATUS)'
+      },
+      source_input_id: 'foreign_uuid',
+      created_at: 'created_at',
+      modified_at: 'modified_at'
+    },
+    indexes: [
+      { columns: 'id', primary: true },
+      { columns: ['start'] },
+      { columns: ['end'] },
+      { columns: ['status'] },
+      { columns: ['source_input_id'] }
+    ]
+  },
+  {
+    name: 'person_event',
+    columns: {
+      id: 'id',
+      event_id: {
+        type: 'foreign_uuid',
+        nullable: false,
+        description: 'Event this person is linked to'
+      },
+      person_id: 'person_id',
+      response: {
+        type: 'string',
+        nullable: false,
+        default_value: 'Invited',
+        values: ['Invited', 'Accepted', 'Declined', 'Tentative', 'Attended'],
+        description:
+          'RSVP / attendance (iCal ATTENDEE PARTSTAT). Invited≈NEEDS-ACTION; Accepted/Declined/Tentative match PARTSTAT; Attended is post-event check-in beyond iCal'
+      },
+      role: {
+        type: 'string',
+        nullable: false,
+        default_value: 'Required',
+        values: ['Required', 'Optional', 'Chair', 'Non-Participant'],
+        description: 'Participation role (iCal ATTENDEE ROLE, simplified)'
+      },
+      responded_at: {
+        type: 'datetime',
+        description: 'When the person last set response (Attend / Decline / Tentative)'
+      },
+      source_input_id: 'foreign_uuid',
+      created_at: 'created_at',
+      modified_at: 'modified_at'
+    },
+    indexes: [
+      { columns: 'id', primary: true },
+      { columns: ['person_id'] },
+      { columns: ['event_id'] },
+      { columns: ['response'] },
+      { columns: ['event_id', 'person_id'], unique: true }
+    ]
+  }
+];
+
+export default {
+  tables
+};

package/event/search.js

@@ -0,0 +1,51 @@
+const RESPONSE_VALUES = ['Invited', 'Accepted', 'Declined', 'Tentative', 'Attended'];
+
+export const responses = {
+  title: 'Event responses',
+  description: 'People linked to events by RSVP / attendance response',
+  form: {
+    title: 'Event responses',
+    type: 'object',
+    properties: {
+      response: {
+        type: 'string',
+        enum: RESPONSE_VALUES
+      },
+      eventId: {
+        type: 'string',
+        description: 'Limit to one event UUID'
+      }
+    },
+    required: []
+  },
+  optionsToEQL(options) {
+    const { response, eventId } = options;
+    let text = 'Has an event response';
+    const conditions = [];
+    if (response) {
+      text = `Event response is ${response}`;
+      conditions.push({
+        type: 'EQUALS',
+        values: [{ ref: { column: 'response' } }, { value: { value: response } }]
+      });
+    }
+    if (eventId) {
+      text += ` for event ${eventId}`;
+      conditions.push({
+        type: 'EQUALS',
+        values: [{ ref: { column: 'event_id' } }, { value: { value: eventId } }]
+      });
+    }
+    return {
+      text,
+      eql: {
+        table: 'person_event',
+        conditions
+      }
+    };
+  }
+};
+
+export default {
+  responses
+};

package/message/index.js

@@ -0,0 +1,8 @@
+const metadata = {
+  name: '@engine9/schemas/message',
+  schemas: ['schema.js']
+};
+export { metadata };
+export default {
+  metadata
+};