@owlmeans/bot-postgres 0.0.0-stage → 0.1.18-rc.2

package/README.md

@@ -1,3 +1,144 @@
-# Temporary Holding Version
+# @owlmeans/bot-postgres
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+PostgreSQL storage for `@owlmeans/server-bot`: it registers the four resources the `BotService`
+resolves by alias — `bot-connection`, `bot-rule`, `bot-update` (the inbox) and `bot-activity` — with
+the shared AJV schemas and the indexes the service reads by. A Postgres-backed server (typically a
+generated target project) adds it next to `appendBot`.
+
+## Installation
+
+```bash
+bun add @owlmeans/bot-postgres@^0.1.18-rc.2
+```
+
+Peer dependencies: `pg`, `ajv`.
+
+## Concepts
+
+- **Four resources** — `BotConnectionResource`, `BotRuleResource`, `BotUpdateResource` and
+  `BotActivityResource`, each a `PostgresResource` of the matching `@owlmeans/server-bot` record, at
+  the aliases `RES_BOT_CONNECTION`, `RES_BOT_RULE`, `RES_BOT_UPDATE`, `RES_BOT_ACTIVITY`.
+- **Shared schemas** — `resource.schema` is exactly `server-bot`'s record schema; this package
+  declares no schema of its own.
+- **Column shapes** — nested objects (`identity`, the inbox `update`, the activity `target`) are one
+  `jsonb` column each; string lists (`keywords`, `setup`, `credentialsSet`, `handled`) are `text[]`;
+  timestamps are ISO `text`; the sealed credentials are one `text` column; the rule's `order` is a
+  quoted `double precision` column.
+- **Unique inbox key** — `dedupe` carries a unique index, so a redelivered update is one row even
+  when two deliveries race.
+- **Ids** — records are created without one; Postgres mints it.
+
+## Usage
+
+### Register the resources and the service
+
+```typescript
+import { appendPostgres } from '@owlmeans/postgres'
+import { appendPostgresBot } from '@owlmeans/bot-postgres'
+import { appendBot } from '@owlmeans/server-bot'
+
+appendPostgres(context)              // the Postgres connection service, cfg.dbs[...]
+appendPostgresBot(context)           // the four resources
+appendBot(context)                   // the service that resolves them by alias
+
+await context.configure().init()     // resource init reconciles tables and indexes (meta.autoSync, default Full)
+```
+
+`appendPostgresBot` skips a resource whose alias is already registered, so calling it twice is safe.
+
+### Another database, connection service or alias set
+
+```typescript
+const resources = { connection: 'chat-connection', rule: 'chat-rule', update: 'chat-update', activity: 'chat-activity' }
+
+appendPostgresBot(context, { dbAlias: 'bots', serviceAlias: 'postgres-secondary', resources })
+appendBot(context, { resources })
+```
+
+### One resource per file (a generated target)
+
+The second maker argument is the resource alias, so a target's file wraps the maker into a
+`ResourceMaker`:
+
+```typescript
+// sources/backend/src/resources/bot/connection.ts
+import { makeBotConnectionResource } from '@owlmeans/bot-postgres'
+import type { BotConnectionResource } from '@owlmeans/bot-postgres'
+import { RES_BOT_CONNECTION } from '@owlmeans/server-bot'
+import type { BotConnectionRecord } from '@owlmeans/server-bot'
+import type { ResourceMaker } from '@owlmeans/resource'
+
+export const makeResource: ResourceMaker<BotConnectionRecord, BotConnectionResource> =
+  (dbAlias, serviceAlias) => makeBotConnectionResource(dbAlias, RES_BOT_CONNECTION, serviceAlias)
+```
+
+`rule.ts`, `update.ts` and `activity.ts` follow the same shape.
+
+## API
+
+| Symbol | Kind | Purpose |
+|---|---|---|
+| `appendPostgresBot(ctx, opts?)` | function | Registers the four resources, each only if its alias is free |
+| `makeBotConnectionResource(dbAlias?, alias?, serviceAlias?)` | function | `BotConnectionResource` |
+| `makeBotRuleResource(dbAlias?, alias?, serviceAlias?)` | function | `BotRuleResource` |
+| `makeBotUpdateResource(dbAlias?, alias?, serviceAlias?)` | function | `BotUpdateResource` (the inbox) |
+| `makeBotActivityResource(dbAlias?, alias?, serviceAlias?)` | function | `BotActivityResource` |
+| `BotPostgresOptions` | type | `{ dbAlias?, serviceAlias?, resources? }` |
+
+### Indexes
+
+Named `<table>_<suffix>`:
+
+| Table | Suffix | Columns |
+|---|---|---|
+| `bot_connection` | `scope_created` | `scope`, `createdAt` |
+| `bot_connection` | `receive` | `enabled`, `status`, `receive` |
+| `bot_rule` | `scope` | `scope` |
+| `bot_rule` | `scope_connection` | `scope`, `connection` |
+| `bot_update` | `dedupe` (unique) | `dedupe` |
+| `bot_update` | `inbox` | `status`, `receivedAt` |
+| `bot_update` | `lease` | `status`, `claimedAt` |
+| `bot_update` | `connection_received` | `connection`, `receivedAt` |
+| `bot_update` | `retention` | `status`, `processedAt` |
+| `bot_activity` | `scope_at` | `scope`, `at` |
+| `bot_activity` | `scope_connection_at` | `scope`, `connection`, `at` |
+
+## Testing
+
+`tests/schema.spec.ts` needs no database: it compiles the shared schemas and asserts the column
+types, the quoted `order` column, the declared indexes and idempotent registration.
+`tests/conformance.spec.ts` (the `@owlmeans/server-bot/conformance` store suite, every case including
+the unique one) and `tests/tables.spec.ts` (a second boot plans no DDL; the round trips) are
+integration suites gated on `POSTGRES_URL`; they skip without one.
+
+## Common pitfalls
+
+- Using a maker directly as a `ResourceMaker` — its second argument is the resource alias, not the
+  service alias.
+- Registering custom aliases here but not on `appendBot` — the service looks the defaults up and fails.
+- Redeclaring a schema locally — the table would drift from what the service reads and writes.
+
+The `bot-postgres` skill covers this package; the `server-bot` skill covers the records and the service.
+
+## Related packages
+
+- [`@owlmeans/server-bot`](../server-bot) — the service, record types, schemas, aliases and the conformance suite
+- [`@owlmeans/bot`](../bot) — the chat-bot contract
+- [`@owlmeans/postgres-resource`](../postgres-resource) — `makePostgresResource`, `index()`, the schema-to-table compiler
+- [`@owlmeans/postgres`](../postgres) — `appendPostgres`, the connection service
+
+<!-- owlmeans:agent-guidance:start -->
+## Agent guidance
+
+This package ships embedded agent skills under `agent-meta/`. After installing your
+`@owlmeans/*` packages, run the OwlMeans agent-skills installer to place them into
+your project's skill store (`.agents/skills/`):
+
+```sh
+npx @owlmeans/agent-skills@^0.1.18-rc.59
+```
+
+The embedded files are version-matched to this package release. Do not edit them
+directly — they are regenerated on each publish. To contribute guidance edits,
+open a PR against the source monorepo.
+<!-- owlmeans:agent-guidance:end -->

package/agent-meta/manifest.json

@@ -0,0 +1,16 @@
+{
+  "schemaVersion": 3,
+  "package": "@owlmeans/bot-postgres",
+  "version": "0.1.18-rc.2",
+  "generatedAt": "2026-10-26T22:23:53.840Z",
+  "canonicalRepo": "https://github.com/owlmeans/common",
+  "entries": [
+    {
+      "kind": "skill",
+      "name": "bot-postgres",
+      "category": "package-specific",
+      "file": "skills/bot-postgres/SKILL.md",
+      "canonicalPath": ".agents/skills/bot-postgres/SKILL.md"
+    }
+  ]
+}

package/agent-meta/skills/bot-postgres/SKILL.md

@@ -0,0 +1,181 @@
+---
+name: bot-postgres
+description: How to use @owlmeans/bot-postgres — the Postgres extension that registers the four @owlmeans/server-bot resources (bot-connection, bot-rule, bot-update, bot-activity) for a GENERATED TARGET PROJECT, their table shapes and indexes, the unique inbox dedupe key, and the target's resource seed files. Auto-invoked when wiring bot storage into a target's Postgres backend, writing a target's resources/bot/*.ts, or touching the bot tables' shape or indexes.
+user-invocable: false
+---
+<!-- AUTO-GENERATED — do not edit. Regenerate via sync-agent-meta. -->
+
+# @owlmeans/bot-postgres
+
+**Layer:** Infra extension
+**Install:** `"@owlmeans/bot-postgres": "^0.1.18-rc.2"` in `dependencies` (peers `pg`, `ajv`)
+
+The Postgres store of `@owlmeans/server-bot`: four `@owlmeans/postgres-resource` resources over the
+record schemas `server-bot` declares, plus the indexes its reads need. It owns no bot behaviour — the
+`BotService` resolves the four by alias on every call, so this package and `appendBot` are registered
+independently, in any order.
+
+## Key Exports
+
+| Export | Description |
+|--------|-------------|
+| `makeBotConnectionResource(dbAlias?, alias?, serviceAlias?)` | `BotConnectionResource` (`PostgresResource<BotConnectionRecord>`), alias default `RES_BOT_CONNECTION` |
+| `makeBotRuleResource(dbAlias?, alias?, serviceAlias?)` | `BotRuleResource`, default `RES_BOT_RULE` |
+| `makeBotUpdateResource(dbAlias?, alias?, serviceAlias?)` | `BotUpdateResource` — the inbox, default `RES_BOT_UPDATE` |
+| `makeBotActivityResource(dbAlias?, alias?, serviceAlias?)` | `BotActivityResource`, default `RES_BOT_ACTIVITY` |
+| `appendPostgresBot(ctx, opts?)` | Registers the four, each only while its alias is free — idempotent |
+| `BotPostgresOptions` | `{ dbAlias?, serviceAlias?, resources?: BotResourceAliases }` |
+
+`dbAlias` is the `cfg.dbs` entry (default `postgres`), `serviceAlias` the connection service (default
+`postgres`). The second argument is the RESOURCE alias, not the service alias — so a maker is not a
+`ResourceMaker` as is; a target file wraps it (below).
+
+## The schema is imported, never redeclared
+
+Each maker assigns `BotConnectionRecordSchema` / `BotRuleRecordSchema` / `BotUpdateRecordSchema` /
+`BotActivityRecordSchema` from `@owlmeans/server-bot` to `resource.schema` — the same object, never a
+copy, and no `pg:` override. A change to a record is a change to `server-bot`'s schema; this package
+follows it at the next boot (`PgAutoSync.Full` reconciles the table).
+
+## Table shapes
+
+What `postgres-resource`'s default compiler makes of the shared schemas (`tests/schema.spec.ts` pins it):
+
+| Values | Column | Properties |
+|---|---|---|
+| nested objects | one `jsonb` column each | `identity`, the inbox `update` (open: `raw` is the platform's payload), the activity `target` |
+| string lists | native `text[]` | `setup`, `credentialsSet`, `keywords`, `handled` |
+| timestamps | `text` (ISO, sortable as stored — no `format`, so never `timestamptz`) | `createdAt`, `updatedAt`, `receivedAt`, `claimedAt`, `retryAt`, `processedAt`, `at` |
+| sealed credentials | ONE `text` column, never split per credential key | `sealed` (`v1.<iv>.<tag>.<ciphertext>`) |
+| enums | `text` + `CHECK` | `platform`, `transport`, `status`, `receive`, `mode`, `action` |
+| `order` (a reserved word) | `double precision`, quoted wherever the store names it | rule `order` |
+
+Records are created without an `id` (Postgres mints `gen_random_uuid()::text`); `update`/`save` with an
+id REPLACES the whole row. Absent optional fields come back `null`; the service reads `null` as absent.
+
+## Indexes
+
+Index names are `<table>_<suffix>`, so a second set of bot tables under custom aliases in the same
+schema never collides; a maker run twice declares each index once.
+
+| Table | Index | Columns | Serves |
+|---|---|---|---|
+| `bot_connection` | `scope_created` | `scope`, `createdAt` | a scope's connections in order |
+| `bot_connection` | `receive` | `enabled`, `status`, `receive` | the worker's receiver reconciliation |
+| `bot_rule` | `scope` | `scope` | a scope's rules |
+| `bot_rule` | `scope_connection` | `scope`, `connection` | a connection's own rules, the remove cascade |
+| `bot_update` | `dedupe` **UNIQUE** | `dedupe` | one row per redelivered update |
+| `bot_update` | `inbox` | `status`, `receivedAt` | pending rows, oldest first |
+| `bot_update` | `lease` | `status`, `claimedAt` | expired `processing` claims |
+| `bot_update` | `connection_received` | `connection`, `receivedAt` | a connection's newest update, its inbox purge |
+| `bot_update` | `retention` | `status`, `processedAt` | the purge of old `done` rows |
+| `bot_activity` | `scope_at` | `scope`, `at` | the activity feed, newest first |
+| `bot_activity` | `scope_connection_at` | `scope`, `connection`, `at` | one connection's feed |
+
+The unique `dedupe` is the store's backstop against two concurrent deliveries: the loser's `create`
+throws `RecordExists` and the service reads the stored row back. It is what qualifies this store for
+the conformance suite's `unique` capability.
+
+## Target wiring
+
+**Backs:** chat-bot connections with sealed credentials, keyword rules, the inbound update inbox and the bots' activity log
+
+| Sub-project | Packages |
+|---|---|
+| backend | `@owlmeans/bot-postgres`, `@owlmeans/server-bot`, `@owlmeans/bot` |
+
+One file per resource under `sources/backend/src/resources/bot/`: the generated registry imports each
+file's zero-argument `makeResource` and registers it before `init()` creates the table. The path
+names the alias (`bot/connection.ts` → `bot-connection`), which is exactly `server-bot`'s default, so
+`appendBot(context)` needs no `resources` option. The bot service itself, the api trees and the
+worker runtime are `server-bot`'s wiring.
+
+```ts file=sources/backend/src/resources/bot/connection.ts
+import { makeBotConnectionResource } from '@owlmeans/bot-postgres'
+import type { BotConnectionResource } from '@owlmeans/bot-postgres'
+import { RES_BOT_CONNECTION } from '@owlmeans/server-bot'
+import type { BotConnectionRecord } from '@owlmeans/server-bot'
+import type { ResourceMaker } from '@owlmeans/resource'
+
+/**
+ * The bot's connections (`bot-connection`) — credentials sealed with APP_SECRET, never stored in
+ * clear. The maker is a thin wrapper: the schema and indexes are the package's own.
+ */
+export const makeResource: ResourceMaker<BotConnectionRecord, BotConnectionResource> =
+  (dbAlias, serviceAlias) => makeBotConnectionResource(dbAlias, RES_BOT_CONNECTION, serviceAlias)
+```
+
+```ts file=sources/backend/src/resources/bot/rule.ts
+import { makeBotRuleResource } from '@owlmeans/bot-postgres'
+import type { BotRuleResource } from '@owlmeans/bot-postgres'
+import { RES_BOT_RULE } from '@owlmeans/server-bot'
+import type { BotRuleRecord } from '@owlmeans/server-bot'
+import type { ResourceMaker } from '@owlmeans/resource'
+
+/** The keyword rules (`bot-rule`) — scope-wide or bound to one connection, kept in `order`. */
+export const makeResource: ResourceMaker<BotRuleRecord, BotRuleResource> =
+  (dbAlias, serviceAlias) => makeBotRuleResource(dbAlias, RES_BOT_RULE, serviceAlias)
+```
+
+```ts file=sources/backend/src/resources/bot/update.ts
+import { makeBotUpdateResource } from '@owlmeans/bot-postgres'
+import type { BotUpdateResource } from '@owlmeans/bot-postgres'
+import { RES_BOT_UPDATE } from '@owlmeans/server-bot'
+import type { BotUpdateRecord } from '@owlmeans/server-bot'
+import type { ResourceMaker } from '@owlmeans/resource'
+
+/** The inbox (`bot-update`) — one row per inbound update, unique by its dedupe key; the worker drains it. */
+export const makeResource: ResourceMaker<BotUpdateRecord, BotUpdateResource> =
+  (dbAlias, serviceAlias) => makeBotUpdateResource(dbAlias, RES_BOT_UPDATE, serviceAlias)
+```
+
+```ts file=sources/backend/src/resources/bot/activity.ts
+import { makeBotActivityResource } from '@owlmeans/bot-postgres'
+import type { BotActivityResource } from '@owlmeans/bot-postgres'
+import { RES_BOT_ACTIVITY } from '@owlmeans/server-bot'
+import type { BotActivityRecord } from '@owlmeans/server-bot'
+import type { ResourceMaker } from '@owlmeans/resource'
+
+/** What every bot action did (`bot-activity`) — kept when its connection is removed. */
+export const makeResource: ResourceMaker<BotActivityRecord, BotActivityResource> =
+  (dbAlias, serviceAlias) => makeBotActivityResource(dbAlias, RES_BOT_ACTIVITY, serviceAlias)
+```
+
+All four are required: the service reads and writes every one of them. Never pass a maker to
+`ResourceMaker` directly (`makeResource = makeBotConnectionResource`) — a caller's `serviceAlias`
+would land in the resource-alias position.
+
+## Wiring outside a target
+
+```ts
+import { appendPostgres } from '@owlmeans/postgres'
+import { appendPostgresBot } from '@owlmeans/bot-postgres'
+import { appendBot } from '@owlmeans/server-bot'
+
+appendPostgres(context)          // the connection service, cfg.dbs[...]
+appendPostgresBot(context)       // the four resources
+appendBot(context)               // the service, which resolves them by alias per call
+await context.configure().init() // init reconciles the four tables and their indexes
+```
+
+Custom aliases go to both sides:
+`appendPostgresBot(ctx, { resources })` and `appendBot(ctx, { resources })`.
+
+## Testing
+
+Category C. `bun test ./tests`: `schema.spec.ts` needs no database (the column types, the quoted
+`order`, the declared indexes, the unique dedupe DDL, idempotent registration); `conformance.spec.ts`
+runs `server-bot`'s store suite — `botConformanceCasesFor(['unique'])` over
+`makeBotConformanceSubject(context)`, every case — and `tables.spec.ts` asserts a second boot plans
+no DDL and round-trips the jsonb, `text[]` and `order` columns. Both are gated on `POSTGRES_URL`
+(`gateHelper.postgresGate()`, each spec file its own throwaway schema) and skip cleanly without it.
+With no database of this checkout's own, run them against a throwaway container
+(`docker run --rm -d -p 127.0.0.1:<port>:5432 -e POSTGRES_PASSWORD=… postgres:<tag>`) — never another
+slot's test database. A new conformance case runs here only after `server-bot` is rebuilt.
+
+## Related
+
+- `server-bot` — the service, the record types and schemas, the aliases, the conformance suite (read its skill first)
+- `bot` — the contract the records carry (platforms, statuses, enums)
+- `postgres-resource` — the table compiler, `index()`, the reconciliation · `postgres` — the connection service
+- `marketing-consent-postgres`, `planning-postgres` — the same import-the-schema pattern for other features

package/build/helper.d.ts

@@ -0,0 +1,9 @@
+import type { BasicContext } from '@owlmeans/context';
+import type { BotPostgresOptions } from './types.js';
+/**
+ * Registers the four bot resources, each only while its alias is free — a second call (a context
+ * composed in two places, a hot reload) leaves the registered ones alone. Registration order against
+ * `appendBot` is free: the service resolves its resources by alias on every call.
+ */
+export declare const appendPostgresBot: (ctx: BasicContext<any>, opts?: BotPostgresOptions) => void;
+//# sourceMappingURL=helper.d.ts.map

package/build/helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helper.d.ts","sourceRoot":"","sources":["../src/helper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAMrD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAEpD;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,QAAS,YAAY,CAAC,GAAG,CAAC,SAAQ,kBAAkB,KAAQ,IAmBzF,CAAA"}

package/build/helper.js

@@ -0,0 +1,27 @@
+import { RES_BOT_ACTIVITY, RES_BOT_CONNECTION, RES_BOT_RULE, RES_BOT_UPDATE } from '@owlmeans/server-bot';
+import { makeBotActivityResource, makeBotConnectionResource, makeBotRuleResource, makeBotUpdateResource, } from './resource.js';
+/**
+ * Registers the four bot resources, each only while its alias is free — a second call (a context
+ * composed in two places, a hot reload) leaves the registered ones alone. Registration order against
+ * `appendBot` is free: the service resolves its resources by alias on every call.
+ */
+export const appendPostgresBot = (ctx, opts = {}) => {
+    const { dbAlias, serviceAlias, resources = {} } = opts;
+    const connection = resources.connection ?? RES_BOT_CONNECTION;
+    const rule = resources.rule ?? RES_BOT_RULE;
+    const update = resources.update ?? RES_BOT_UPDATE;
+    const activity = resources.activity ?? RES_BOT_ACTIVITY;
+    if (!ctx.hasResource(connection)) {
+        ctx.registerResource(makeBotConnectionResource(dbAlias, connection, serviceAlias));
+    }
+    if (!ctx.hasResource(rule)) {
+        ctx.registerResource(makeBotRuleResource(dbAlias, rule, serviceAlias));
+    }
+    if (!ctx.hasResource(update)) {
+        ctx.registerResource(makeBotUpdateResource(dbAlias, update, serviceAlias));
+    }
+    if (!ctx.hasResource(activity)) {
+        ctx.registerResource(makeBotActivityResource(dbAlias, activity, serviceAlias));
+    }
+};
+//# sourceMappingURL=helper.js.map

package/build/helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helper.js","sourceRoot":"","sources":["../src/helper.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAEzG,OAAO,EACL,uBAAuB,EAAE,yBAAyB,EAAE,mBAAmB,EAAE,qBAAqB,GAC/F,MAAM,eAAe,CAAA;AAGtB;;;;GAIG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,GAAsB,EAAE,IAAI,GAAuB,EAAE,EAAQ,EAAE;IAC/F,MAAM,EAAE,OAAO,EAAE,YAAY,EAAE,SAAS,GAAG,EAAE,EAAE,GAAG,IAAI,CAAA;IACtD,MAAM,UAAU,GAAG,SAAS,CAAC,UAAU,IAAI,kBAAkB,CAAA;IAC7D,MAAM,IAAI,GAAG,SAAS,CAAC,IAAI,IAAI,YAAY,CAAA;IAC3C,MAAM,MAAM,GAAG,SAAS,CAAC,MAAM,IAAI,cAAc,CAAA;IACjD,MAAM,QAAQ,GAAG,SAAS,CAAC,QAAQ,IAAI,gBAAgB,CAAA;IAEvD,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,UAAU,CAAC,EAAE,CAAC;QACjC,GAAG,CAAC,gBAAgB,CAAC,yBAAyB,CAAC,OAAO,EAAE,UAAU,EAAE,YAAY,CAAC,CAAC,CAAA;IACpF,CAAC;IACD,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC;QAC3B,GAAG,CAAC,gBAAgB,CAAC,mBAAmB,CAAC,OAAO,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC,CAAA;IACxE,CAAC;IACD,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC;QAC7B,GAAG,CAAC,gBAAgB,CAAC,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,CAAC,CAAC,CAAA;IAC5E,CAAC;IACD,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC/B,GAAG,CAAC,gBAAgB,CAAC,uBAAuB,CAAC,OAAO,EAAE,QAAQ,EAAE,YAAY,CAAC,CAAC,CAAA;IAChF,CAAC;AACH,CAAC,CAAA"}

package/build/index.d.ts

@@ -0,0 +1,4 @@
+export type * from './types.js';
+export * from './resource.js';
+export * from './helper.js';
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,mBAAmB,YAAY,CAAA;AAC/B,cAAc,eAAe,CAAA;AAC7B,cAAc,aAAa,CAAA"}

package/build/index.js

@@ -0,0 +1,3 @@
+export * from './resource.js';
+export * from './helper.js';
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,eAAe,CAAA;AAC7B,cAAc,aAAa,CAAA"}

package/build/resource.d.ts

@@ -0,0 +1,23 @@
+import type { BotActivityResource, BotConnectionResource, BotRuleResource, BotUpdateResource } from './types.js';
+/**
+ * `bot-connection` — the connections of every scope. The schema is `server-bot`'s own, assigned, never
+ * copied: `identity` compiles to one `jsonb` column, `setup` and `credentialsSet` to `text[]`, the
+ * sealed credentials to one `text` column. Indexes follow the reads: a scope's list by creation, and
+ * the worker's reconciliation (enabled, connected, polling or on the gateway).
+ */
+export declare const makeBotConnectionResource: (dbAlias?: string, alias?: string, serviceAlias?: string) => BotConnectionResource;
+/**
+ * `bot-rule` — keyword rules, scope-wide (`connection` null) or bound to one connection; `keywords` is
+ * `text[]`, `order` a `double precision` column (quoted wherever the store names it).
+ */
+export declare const makeBotRuleResource: (dbAlias?: string, alias?: string, serviceAlias?: string) => BotRuleResource;
+/**
+ * `bot-update` — the inbox. `dedupe` is UNIQUE: two concurrent deliveries of one platform update
+ * collide here (`RecordExists`) and the service reads the stored row back. The normalized `update`
+ * is one `jsonb` column, `handled` a `text[]`. Indexes follow the dispatcher (pending rows by age,
+ * expired leases), a connection's newest update, and the retention purge.
+ */
+export declare const makeBotUpdateResource: (dbAlias?: string, alias?: string, serviceAlias?: string) => BotUpdateResource;
+/** `bot-activity` — what every action did; `target` is one `jsonb` column. Read newest first per scope. */
+export declare const makeBotActivityResource: (dbAlias?: string, alias?: string, serviceAlias?: string) => BotActivityResource;
+//# sourceMappingURL=resource.d.ts.map

package/build/resource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource.d.ts","sourceRoot":"","sources":["../src/resource.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAoBhH;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,aAC1B,MAAM,UAAS,MAAM,iBAAsC,MAAM,KAC1E,qBASF,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,mBAAmB,aACpB,MAAM,UAAS,MAAM,iBAAgC,MAAM,KACpE,eASF,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,aACtB,MAAM,UAAS,MAAM,iBAAkC,MAAM,KACtE,iBAYF,CAAA;AAED,2GAA2G;AAC3G,eAAO,MAAM,uBAAuB,aACxB,MAAM,UAAS,MAAM,iBAAoC,MAAM,KACxE,mBASF,CAAA"}

package/build/resource.js

@@ -0,0 +1,75 @@
+import { makePostgresResource, pgDeclarationHelper, pgNameHelper } from '@owlmeans/postgres-resource';
+import { BotActivityRecordSchema, BotConnectionRecordSchema, BotRuleRecordSchema, BotUpdateRecordSchema, RES_BOT_ACTIVITY, RES_BOT_CONNECTION, RES_BOT_RULE, RES_BOT_UPDATE, } from '@owlmeans/server-bot';
+/**
+ * Declare the indexes a maker owns, each once. Declarations are kept per alias at module scope, so a
+ * maker that runs twice (a target's file wrapping it, a spec) would otherwise declare every index
+ * again and the compiler would warn about the duplicate on every boot. The name carries the table,
+ * so a second set of bot tables under other aliases in the same schema never collides with the first.
+ */
+const declareIndexes = (resource, alias, indexes) => {
+    const table = pgNameHelper.pgIdentifier(alias);
+    const declared = pgDeclarationHelper.getDeclaration(alias).indexes;
+    for (const [suffix, spec] of indexes) {
+        const name = `${table}_${suffix}`;
+        if (!declared.some(index => index.name === name)) {
+            resource.index(name, spec);
+        }
+    }
+};
+/**
+ * `bot-connection` — the connections of every scope. The schema is `server-bot`'s own, assigned, never
+ * copied: `identity` compiles to one `jsonb` column, `setup` and `credentialsSet` to `text[]`, the
+ * sealed credentials to one `text` column. Indexes follow the reads: a scope's list by creation, and
+ * the worker's reconciliation (enabled, connected, polling or on the gateway).
+ */
+export const makeBotConnectionResource = (dbAlias, alias = RES_BOT_CONNECTION, serviceAlias) => {
+    const resource = makePostgresResource(alias, dbAlias, serviceAlias);
+    resource.schema = BotConnectionRecordSchema;
+    declareIndexes(resource, alias, [
+        ['scope_created', { columns: ['scope', 'createdAt'] }],
+        ['receive', { columns: ['enabled', 'status', 'receive'] }],
+    ]);
+    return resource;
+};
+/**
+ * `bot-rule` — keyword rules, scope-wide (`connection` null) or bound to one connection; `keywords` is
+ * `text[]`, `order` a `double precision` column (quoted wherever the store names it).
+ */
+export const makeBotRuleResource = (dbAlias, alias = RES_BOT_RULE, serviceAlias) => {
+    const resource = makePostgresResource(alias, dbAlias, serviceAlias);
+    resource.schema = BotRuleRecordSchema;
+    declareIndexes(resource, alias, [
+        ['scope', { columns: ['scope'] }],
+        ['scope_connection', { columns: ['scope', 'connection'] }],
+    ]);
+    return resource;
+};
+/**
+ * `bot-update` — the inbox. `dedupe` is UNIQUE: two concurrent deliveries of one platform update
+ * collide here (`RecordExists`) and the service reads the stored row back. The normalized `update`
+ * is one `jsonb` column, `handled` a `text[]`. Indexes follow the dispatcher (pending rows by age,
+ * expired leases), a connection's newest update, and the retention purge.
+ */
+export const makeBotUpdateResource = (dbAlias, alias = RES_BOT_UPDATE, serviceAlias) => {
+    const resource = makePostgresResource(alias, dbAlias, serviceAlias);
+    resource.schema = BotUpdateRecordSchema;
+    declareIndexes(resource, alias, [
+        ['dedupe', { columns: ['dedupe'], unique: true }],
+        ['inbox', { columns: ['status', 'receivedAt'] }],
+        ['lease', { columns: ['status', 'claimedAt'] }],
+        ['connection_received', { columns: ['connection', 'receivedAt'] }],
+        ['retention', { columns: ['status', 'processedAt'] }],
+    ]);
+    return resource;
+};
+/** `bot-activity` — what every action did; `target` is one `jsonb` column. Read newest first per scope. */
+export const makeBotActivityResource = (dbAlias, alias = RES_BOT_ACTIVITY, serviceAlias) => {
+    const resource = makePostgresResource(alias, dbAlias, serviceAlias);
+    resource.schema = BotActivityRecordSchema;
+    declareIndexes(resource, alias, [
+        ['scope_at', { columns: ['scope', 'at'] }],
+        ['scope_connection_at', { columns: ['scope', 'connection', 'at'] }],
+    ]);
+    return resource;
+};
+//# sourceMappingURL=resource.js.map

package/build/resource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource.js","sourceRoot":"","sources":["../src/resource.ts"],"names":[],"mappings":"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"}

package/build/types.d.ts

@@ -0,0 +1,26 @@
+import type { PostgresResource } from '@owlmeans/postgres-resource';
+import type { BotActivityRecord, BotConnectionRecord, BotResourceAliases, BotRuleRecord, BotUpdateRecord } from '@owlmeans/server-bot';
+/** `bot-connection` — one row per connected bot, its credentials sealed in one text column. */
+export interface BotConnectionResource extends PostgresResource<BotConnectionRecord> {
+}
+/** `bot-rule` — the keyword rules of a scope, scope-wide or bound to one connection. */
+export interface BotRuleResource extends PostgresResource<BotRuleRecord> {
+}
+/** `bot-update` — the inbox: one row per inbound platform update, unique by its `dedupe` key. */
+export interface BotUpdateResource extends PostgresResource<BotUpdateRecord> {
+}
+/** `bot-activity` — one row per action a bot took (or refused), newest read first. */
+export interface BotActivityResource extends PostgresResource<BotActivityRecord> {
+}
+export interface BotPostgresOptions {
+    /** The `cfg.dbs` entry the four tables live in — default `postgres`. */
+    dbAlias?: string;
+    /** The Postgres connection service — default `postgres`. */
+    serviceAlias?: string;
+    /**
+     * The resources' aliases — default `bot-connection`, `bot-rule`, `bot-update`, `bot-activity`.
+     * The bot service must be given the same ones (`appendBot(ctx, { resources })`).
+     */
+    resources?: BotResourceAliases;
+}
+//# sourceMappingURL=types.d.ts.map

package/build/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AACnE,OAAO,KAAK,EACV,iBAAiB,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,aAAa,EAAE,eAAe,EAC3F,MAAM,sBAAsB,CAAA;AAE7B,+FAA+F;AAC/F,MAAM,WAAW,qBAAsB,SAAQ,gBAAgB,CAAC,mBAAmB,CAAC;CAAG;AAEvF,wFAAwF;AACxF,MAAM,WAAW,eAAgB,SAAQ,gBAAgB,CAAC,aAAa,CAAC;CAAG;AAE3E,iGAAiG;AACjG,MAAM,WAAW,iBAAkB,SAAQ,gBAAgB,CAAC,eAAe,CAAC;CAAG;AAE/E,sFAAsF;AACtF,MAAM,WAAW,mBAAoB,SAAQ,gBAAgB,CAAC,iBAAiB,CAAC;CAAG;AAEnF,MAAM,WAAW,kBAAkB;IACjC,wEAAwE;IACxE,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,4DAA4D;IAC5D,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB;;;OAGG;IACH,SAAS,CAAC,EAAE,kBAAkB,CAAA;CAC/B"}

package/build/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/build/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/build/types.local.d.ts

@@ -0,0 +1,4 @@
+import type { PgIndexSpec } from '@owlmeans/postgres-resource';
+/** The indexes a maker owns, by name suffix — the full name is `<table>_<suffix>`. */
+export type IndexList = ReadonlyArray<readonly [suffix: string, spec: PgIndexSpec]>;
+//# sourceMappingURL=types.local.d.ts.map

package/build/types.local.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.local.d.ts","sourceRoot":"","sources":["../src/types.local.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AAE9D,sFAAsF;AACtF,MAAM,MAAM,SAAS,GAAG,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,CAAC,CAAC,CAAA"}

package/build/types.local.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.local.js.map

package/build/types.local.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.local.js","sourceRoot":"","sources":["../src/types.local.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,54 @@
 {
   "name": "@owlmeans/bot-postgres",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.18-rc.2",
+  "license": "MIT",
+  "description": "Postgres-backed resources for @owlmeans/server-bot — the connection, rule, inbox and activity tables of a generated target project, compiled from the shared AJV schemas, with the unique inbox dedupe key.",
+  "type": "module",
+  "scripts": {
+    "build": "tsc -b",
+    "dev": "sleep 14 && nodemon -e ts,tsx,json --watch src --exec \"tsc -p ./tsconfig.json\"",
+    "watch": "tsc -b -w --preserveWatchOutput --pretty",
+    "test": "bun test ./tests"
+  },
+  "main": "build/index.js",
+  "module": "build/index.js",
+  "types": "build/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./build/index.js",
+      "require": "./build/index.js",
+      "default": "./build/index.js",
+      "module": "./build/index.js",
+      "types": "./build/index.d.ts"
+    }
+  },
+  "dependencies": {
+    "@owlmeans/context": "^0.1.18-rc.35",
+    "@owlmeans/postgres-resource": "^0.1.18-rc.50",
+    "@owlmeans/resource": "^0.1.18-rc.41",
+    "@owlmeans/server-bot": "^0.1.18-rc.2"
+  },
+  "peerDependencies": {
+    "ajv": "*",
+    "pg": "*"
+  },
+  "devDependencies": {
+    "@owlmeans/bot": "^0.1.18-rc.2",
+    "@owlmeans/dep-config": "workspace:*",
+    "@owlmeans/log": "^0.1.18-rc.4",
+    "@owlmeans/postgres": "^0.1.18-rc.52",
+    "@owlmeans/server-context": "^0.1.18-rc.45",
+    "@owlmeans/test": "^0.1.18-rc.39",
+    "@owlmeans/test-integration": "^0.1.18-rc.37",
+    "@types/bun": "^1.4.2",
+    "@types/node": "^26.6.4",
+    "@types/pg": "^8.23.1",
+    "ajv": "^8.20.0",
+    "nodemon": "^3.1.14",
+    "pg": "^8.23.1",
+    "typescript": "^7.0.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}