@edium/halifax 1.0.0

package/README_QUERYBUILDER.md

@@ -0,0 +1,219 @@
+# Query Builder
+
+The query builder exposes an advanced `POST /:resource/query` endpoint that accepts a structured JSON payload (an AST — abstract syntax tree) describing filters, sorting, pagination, and projection. It lets the front-end compose rich list queries "for free", without the back-end adding custom endpoints. (The path segment defaults to `query`; override it with the `queryBuilderPath` option.)
+
+**Database-agnostic by design.** The payload is fully validated against the resource — every field name, comparison, sort, and nesting depth — and invalid input returns a structured `400`/`422` _before_ any database call. The validated AST is then compiled to portable **Prisma Client** calls (never raw SQL), so the exact same request behaves identically on PostgreSQL, MySQL/MariaDB, SQLite, SQL Server, CockroachDB, and MongoDB. Switch databases by changing only the Prisma `provider` — your client code never changes.
+
+It is enabled by default; disable it per-resource with the `allowReadManyWithQueryBuilder` permission:
+
+```ts
+permissions: {
+  allowReadManyWithQueryBuilder: false,
+}
+```
+
+## Full Payload Reference
+
+```ts
+interface QueryPayload {
+  fields?: string[] // columns to return (default: all)
+  where?: QueryFilter[] // filter conditions
+  orderBy?: SortEntry[] // sort order
+  limit?: number // page size
+  offset?: number // rows to skip
+  distinct?: string[] // return rows distinct on these columns
+}
+```
+
+> The query targets the resource's own model — there is no table name in the payload, so a caller can never point the query at another table.
+
+### `fields`
+
+An optional array of column names to include in the response. Omit it to return all columns (`SELECT *`).
+
+Fields are validated against the resource's field definitions. A field with `selectable: false` returns 400.
+
+```json
+{ "fields": ["id", "title", "published"] }
+```
+
+### `where`
+
+An array of filter conditions. Each entry is a `QueryFilter`:
+
+```ts
+interface QueryFilter {
+  field: string // column name
+  comparison: string // see comparisons table
+  value1?: scalar | scalar[] // primary value (omit for IS NULL / IS NOT NULL)
+  value2?: scalar // second value for BETWEEN / NOT BETWEEN
+  operator?: 'AND' | 'OR' // required for all entries except the last
+  children?: QueryFilter[] // nested group (produces parenthesised sub-clause)
+}
+
+type scalar = string | number | boolean | null
+```
+
+Fields are validated against the resource's field definitions. A field with `filterable: false` returns 400.
+
+#### Comparisons
+
+| `comparison`  | Prisma mapping                          | `value1`                   | `value2` |
+| ------------- | --------------------------------------- | -------------------------- | -------- |
+| `=`           | `{ equals }`                            | scalar                     | —        |
+| `<>`          | `{ not }`                               | scalar                     | —        |
+| `>`           | `{ gt }`                                | scalar                     | —        |
+| `>=`          | `{ gte }`                               | scalar                     | —        |
+| `<`           | `{ lt }`                                | scalar                     | —        |
+| `<=`          | `{ lte }`                               | scalar                     | —        |
+| `LIKE`        | `{ contains / startsWith / endsWith }`† | string (use `%` wildcards) | —        |
+| `NOT LIKE`    | `{ NOT: … }`                            | string                     | —        |
+| `CONTAINS`    | `{ contains }`                          | string                     | —        |
+| `STARTS WITH` | `{ startsWith }`                        | string                     | —        |
+| `ENDS WITH`   | `{ endsWith }`                          | string                     | —        |
+| `IN`          | `{ in }`                                | array of scalars           | —        |
+| `NOT IN`      | `{ notIn }`                             | array of scalars           | —        |
+| `BETWEEN`     | `{ gte, lte }`                          | scalar                     | scalar   |
+| `NOT BETWEEN` | `{ OR: [{ lt }, { gt }] }`              | scalar                     | scalar   |
+| `IS NULL`     | `field: null`                           | —                          | —        |
+| `IS NOT NULL` | `{ not: null }`                         | —                          | —        |
+
+† `LIKE` parses `%` wildcards: `%x%` → `contains`, `x%` → `startsWith`, `%x` → `endsWith`, and a wildcard-free value collapses to `equals`. The portable `CONTAINS` / `STARTS WITH` / `ENDS WITH` operators (supported by both Prisma and Drizzle) are the recommended, dialect-independent way to do substring matching — unlike SQL `LIKE`, whose case-sensitivity varies by engine collation.
+
+#### Examples
+
+Simple equality:
+
+```json
+{ "field": "published", "comparison": "=", "value1": true }
+```
+
+Multi-condition with AND:
+
+```json
+[
+  { "field": "published", "comparison": "=", "value1": true, "operator": "AND" },
+  { "field": "title", "comparison": "LIKE", "value1": "%typescript%" }
+]
+```
+
+IN list:
+
+```json
+{ "field": "authorId", "comparison": "IN", "value1": [1, 2, 3] }
+```
+
+NULL check:
+
+```json
+{ "field": "deletedAt", "comparison": "IS NULL" }
+```
+
+Range:
+
+```json
+{ "field": "score", "comparison": "BETWEEN", "value1": 10, "value2": 100 }
+```
+
+#### Nested filters (parenthesised groups)
+
+Use `children` to wrap a group of conditions in parentheses:
+
+```json
+{
+  "where": [
+    { "field": "published", "comparison": "=", "value1": true, "operator": "AND" },
+    {
+      "operator": "OR",
+      "children": [
+        { "field": "authorId", "comparison": "=", "value1": 1, "operator": "OR" },
+        { "field": "authorId", "comparison": "=", "value1": 2 }
+      ]
+    }
+  ]
+}
+```
+
+Produces: `WHERE published = $1 AND (authorId = $2 OR authorId = $3)`
+
+### `orderBy`
+
+An array of sort directives. Each entry:
+
+```ts
+interface SortEntry {
+  field: string // column name — must be a defined, sortable resource field
+  order: 'ASC' | 'DESC'
+}
+```
+
+Fields with `sortable: false` return 400. When `orderBy` is omitted the query defaults to `ORDER BY id ASC`.
+
+```json
+{
+  "orderBy": [
+    { "field": "createdAt", "order": "DESC" },
+    { "field": "id", "order": "ASC" }
+  ]
+}
+```
+
+### `limit`
+
+Maximum number of rows to return. If the resource has a `maxLimit` configured, requests above that value are silently capped.
+
+```json
+{ "limit": 25 }
+```
+
+### `offset`
+
+Number of rows to skip before returning results. Use with `limit` for pagination.
+
+```json
+{ "limit": 25, "offset": 50 }
+```
+
+Pagination maps to Prisma `take`/`skip`, so it works identically on every supported database.
+
+### `distinct`
+
+Return only rows distinct on the given columns (maps to Prisma `distinct`; supported by both Prisma and Drizzle). Columns are validated against the resource like any other field.
+
+```json
+{ "distinct": ["authorId"], "fields": ["authorId"] }
+```
+
+## Full Example
+
+```json
+POST /api/v1/posts/query
+{
+  "fields":  ["id", "title", "authorId", "createdAt"],
+  "where": [
+    { "field": "published", "comparison": "=",        "value1": true,  "operator": "AND" },
+    { "field": "title",     "comparison": "CONTAINS",  "value1": "api" }
+  ],
+  "orderBy": [{ "field": "createdAt", "order": "DESC" }],
+  "limit":   25,
+  "offset":  0
+}
+```
+
+## Response
+
+```json
+{
+  "count": 142,
+  "results": [
+    {
+      "id": 7,
+      "title": "Building APIs with Halifax",
+      "authorId": 2,
+      "createdAt": "2025-01-15T10:00:00.000Z"
+    }
+  ]
+}
+```
+
+`count` is the total number of matching rows (before pagination), not the length of `results`.

package/README_REPO_ADAPTERS.md

@@ -0,0 +1,266 @@
+# Repositories
+
+A repository is the data-access layer Halifax talks to. All adapters implement the same `Repository` interface, so you can swap ORM/database without touching your routes or auth.
+
+## The Repository Interface
+
+```ts
+interface Repository<TRecord, TCreate, TUpdate> {
+  readonly capabilities?: Partial<RepositoryCapabilities>
+
+  getOne(
+    id: string | number,
+    options?: { fields?: string[]; include?: string[] }
+  ): Promise<TRecord | null>
+  getMany(options?: ListOptions): Promise<ListResult<TRecord>>
+  createOne(data: TCreate): Promise<TRecord>
+  createMany(data: TCreate[]): Promise<TRecord[]>
+  updateOne(id: string | number, data: TUpdate): Promise<TRecord | null>
+  deleteOne(id: string | number): Promise<boolean>
+
+  // Optional bulk / query-builder operations (PrismaAdapter implements all three)
+  updateMany?(query: IQueryOptions, data: TUpdate): Promise<UpdateManyResult<TRecord>>
+  deleteMany?(query: IQueryOptions): Promise<DeleteManyResult>
+  executeQuery?(query: IQueryOptions): Promise<QueryResult<TRecord>>
+}
+```
+
+## Repository Capabilities
+
+Repositories declare what they support through a `capabilities` property. Read it to make runtime decisions without guessing:
+
+```ts
+interface RepositoryCapabilities {
+  supportsIncludes: boolean // ORM relation loading
+  supportsTransactions: boolean // transaction wrapping
+  supportsCreateManyReturn: boolean // createMany returns the created records
+  supportsQueryAst: boolean // executes the query-builder AST
+}
+```
+
+`PrismaAdapter` implements `updateMany` / `deleteMany` / `executeQuery` for every database (they compile to portable Prisma Client calls) and reports `supportsQueryAst: true`.
+
+## Prisma 7 Repository Adapter
+
+### 1. Define your Prisma schema
+
+With Prisma 7, the datasource block no longer accepts a `url` property. The URL goes in `prisma.config.ts` for CLI tools, and in a driver adapter for the runtime client.
+
+```prisma
+// prisma/schema.prisma
+datasource db {
+  provider = "postgresql"
+}
+
+generator client {
+  provider = "prisma-client-js"
+}
+
+model Post {
+  id        Int      @id @default(autoincrement())
+  title     String
+  content   String?
+  published Boolean  @default(false)
+  authorId  Int?
+  author    Author?  @relation(fields: [authorId], references: [id])
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@map("posts")
+}
+
+model Author {
+  id    Int    @id @default(autoincrement())
+  name  String
+  email String @unique
+  posts Post[]
+
+  @@map("authors")
+}
+```
+
+Create `prisma.config.ts` at the project root so `prisma generate`, `prisma migrate`, and `prisma db push` can find the database URL:
+
+```ts
+// prisma.config.ts
+import { defineConfig } from 'prisma/config'
+
+export default defineConfig({
+  datasource: { url: process.env.DATABASE_URL }
+})
+```
+
+```bash
+pnpm exec prisma generate
+pnpm exec prisma migrate dev --name init
+```
+
+### 2. Create the Prisma client
+
+Prisma 7 requires a driver adapter at runtime. Install `@prisma/adapter-pg` for PostgreSQL:
+
+```bash
+pnpm add @prisma/adapter-pg pg
+pnpm add -D @types/pg
+```
+
+```ts
+// src/db.ts
+import { PrismaClient } from '@prisma/client'
+import { PrismaPg } from '@prisma/adapter-pg'
+
+const adapter = new PrismaPg(process.env.DATABASE_URL!)
+export const prisma = new PrismaClient({ adapter })
+```
+
+### 3. Create a `PrismaAdapter`
+
+```ts
+import { PrismaAdapter } from '@edium/halifax'
+import type { Post, Prisma } from '@prisma/client'
+import { prisma } from './db.js'
+
+export const postRepository = new PrismaAdapter<
+  Post,
+  Prisma.PostCreateInput,
+  Prisma.PostUpdateInput
+>({
+  delegate: prisma.post // no cast needed
+})
+```
+
+Just the model delegate — CRUD, bulk operations, and the query builder all run through it.
+
+#### Options
+
+| Option          | Type      | Required | Description                                                          |
+| --------------- | --------- | -------- | -------------------------------------------------------------------- |
+| `delegate`      | `any`     | yes      | The Prisma model delegate (`prisma.post`, `prisma.user`, …)          |
+| `idField`       | `string`  | no       | Primary key field name (default: `"id"`)                             |
+| `returnCreated` | `boolean` | no       | When `true`, `createMany` returns created records (default: `false`) |
+
+#### `createMany` and returned records
+
+By default, `createMany` uses Prisma's bulk insert for efficiency but returns an empty array because Prisma's `createMany` does not return the created rows. Set `returnCreated: true` to fall back to serial `createOne` calls and receive the full records:
+
+```ts
+new PrismaAdapter({
+  delegate: prisma.post,
+  returnCreated: true // slower, but returns created records
+})
+```
+
+`capabilities.supportsCreateManyReturn` reflects this setting.
+
+### `select` vs `include`
+
+`select` (field projection) and `include` (relation loading) are mutually exclusive in Prisma. The adapter enforces this automatically: when `fields` is specified, it builds a `select` and ignores `include`; when only `include` is specified, it builds an `include`.
+
+## Supported Databases
+
+The **same `PrismaAdapter`** works with every database Prisma supports — there is no adapter-per-database. All CRUD and the query builder compile to portable Prisma Client calls, so behaviour is identical across engines. To switch databases you change only the Prisma `provider` and driver adapter:
+
+| Database        | Prisma `provider` | Driver adapter                   |
+| --------------- | ----------------- | -------------------------------- |
+| PostgreSQL      | `postgresql`      | `@prisma/adapter-pg`             |
+| CockroachDB     | `cockroachdb`     | `@prisma/adapter-pg`             |
+| MySQL / MariaDB | `mysql`           | `@prisma/adapter-mariadb`        |
+| SQL Server      | `sqlserver`       | `@prisma/adapter-mssql`          |
+| SQLite          | `sqlite`          | `@prisma/adapter-better-sqlite3` |
+| MongoDB         | `mongodb`         | _(built-in connector)_           |
+
+The integration suite runs unchanged against PostgreSQL, MySQL, and SQLite in CI to keep this honest; the others use the same harness (`HALIFAX_DB=<db>`).
+
+**MongoDB note.** Mongo keys are 24-character `ObjectId` strings (`@id @default(auto()) @map("_id") @db.ObjectId`). Halifax's `:id` route validation accepts integers, UUIDs, **and** ObjectIds, so id-based routes work on Mongo out of the box.
+
+## Targeting database Views
+
+A database **view is just a model** to Halifax. Prisma exposes a `view` block as a delegate with the same read API as a model (`prisma.activeUsers.findMany()`), so you point a resource's repository at it and disable writes:
+
+```ts
+const activeUsersResource: ResourceDefinition = {
+  name: 'ActiveUser',
+  routePrefix: 'active-users',
+  fields: [{ name: 'id' }, { name: 'email', filterable: true }],
+  permissions: {
+    allowReadOne: true,
+    allowReadMany: true,
+    allowReadManyWithQueryBuilder: true,
+    allowCreate: false,
+    allowUpdateOne: false,
+    allowUpdateMany: false,
+    allowUpsertOne: false,
+    allowDeleteOne: false,
+    allowDeleteMany: false
+  },
+  repository: new PrismaAdapter({ delegate: prisma.activeUsers })
+}
+```
+
+No adapter changes are needed — reads, filtering, sorting, pagination, and the query builder all work against the view. (Drizzle views behave the same way.)
+
+## Caching
+
+Any resource can be served through a pluggable read-through cache (in-memory or Redis), with
+per-resource TTLs, a never-expire mode, automatic write-invalidation, tenant-safe keys, and a
+cache-bust header:
+
+```ts
+const postResource: ResourceDefinition = {
+  /* … */
+  cache: { ttlSeconds: 60 } // cache reads for 60s; writes invalidate automatically
+}
+```
+
+See **[README_CACHE.md](./README_CACHE.md)** for in-memory and Redis examples, the
+never-expire (`ttlSeconds: 0`) and `cache: false` options, and the `Cache-Control: no-cache`
+bust header.
+
+## Implementing a Custom Repository
+
+Any class or object that satisfies the `Repository` interface works:
+
+```ts
+import type { Repository, ListResult } from '@edium/halifax'
+
+export class InMemoryRepository<T extends { id: number }> implements Repository<
+  T,
+  Omit<T, 'id'>,
+  Partial<T>
+> {
+  private records: T[] = []
+  private nextId = 1
+
+  async getOne(id: string | number) {
+    return this.records.find((r) => r.id === Number(id)) ?? null
+  }
+
+  async getMany(): Promise<ListResult<T>> {
+    return { count: this.records.length, results: [...this.records] }
+  }
+
+  async createOne(data: Omit<T, 'id'>) {
+    const record = { id: this.nextId++, ...data } as T
+    this.records.push(record)
+    return record
+  }
+
+  async createMany(data: Omit<T, 'id'>[]) {
+    return Promise.all(data.map((d) => this.createOne(d)))
+  }
+
+  async updateOne(id: string | number, data: Partial<T>) {
+    const record = this.records.find((r) => r.id === Number(id))
+    if (!record) return null
+    Object.assign(record, data)
+    return record
+  }
+
+  async deleteOne(id: string | number) {
+    const idx = this.records.findIndex((r) => r.id === Number(id))
+    if (idx === -1) return false
+    this.records.splice(idx, 1)
+    return true
+  }
+}
+```

package/dist/adapters/http/ExpressAdapter.d.ts

@@ -0,0 +1,40 @@
+import type { Express } from 'express';
+import { Router } from 'express';
+import type { HttpMethod, HttpRouteHandler, HttpServer } from '../../core/types.js';
+import { type CrudApiOptions } from '../../core/crudRouter.js';
+import type { ResourceDefinition } from '../../core/types.js';
+/** Adapts an Express `App` or `Router` to Halifax's {@link HttpServer} interface. */
+export declare class ExpressHttpServer implements HttpServer {
+    private readonly app;
+    /**
+     * @param app - Express application or router to register routes on.
+     *   When an `App` is provided, `start()` will call `listen()`.
+     *   When a `Router` is provided, `start()` is a no-op.
+     */
+    constructor(app: Express | Router);
+    /**
+     * Registers a route on the Express app for the given method and path.
+     * @param method - HTTP method (or `'*'` to register a catch-all via `app.all`).
+     * @param path - Route path pattern (e.g. `'/users/:id'`).
+     * @param handler - Halifax route handler to invoke on matching requests.
+     */
+    registerRoute(method: HttpMethod, path: string, handler: HttpRouteHandler): void;
+    /**
+     * Starts the Express server. No-op when the underlying app does not expose a `listen` method
+     * (e.g. when `app` is a `Router` mounted on an existing Express app).
+     * @param port - TCP port number to bind to.
+     * @param host - Hostname or IP address to bind to (defaults to all interfaces when omitted).
+     */
+    start(port: number, host?: string): Promise<void>;
+}
+/** Options for {@link createExpressCrudRouter}. Alias of {@link CrudApiOptions}. */
+export type ExpressCrudRouterOptions = CrudApiOptions;
+/**
+ * Creates a fully-wired Express `Router` with CRUD routes for every resource.
+ *
+ * @param resources - Resource definitions to register (use {@link createPrismaResources} to generate these).
+ * @param options - Auth strategy, query-builder path overrides, etc.
+ * @returns An Express `Router` ready to mount with `app.use('/api', router)`.
+ */
+export declare function createExpressCrudRouter(resources: ResourceDefinition[], options?: ExpressCrudRouterOptions): Router;
+//# sourceMappingURL=ExpressAdapter.d.ts.map

package/dist/adapters/http/ExpressAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpressAdapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/http/ExpressAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAqB,MAAM,SAAS,CAAA;AACzD,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAChC,OAAO,KAAK,EACV,UAAU,EAGV,gBAAgB,EAChB,UAAU,EACX,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAmB,KAAK,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAC3E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AAuDzD,qFAAqF;AACrF,qBAAa,iBAAkB,YAAW,UAAU;IAM/B,OAAO,CAAC,QAAQ,CAAC,GAAG;IALvC;;;;OAIG;gBACiC,GAAG,EAAE,OAAO,GAAG,MAAM;IAEzD;;;;;OAKG;IACI,aAAa,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,GAAG,IAAI;IAWvF;;;;;OAKG;IACU,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAS/D;AAED,oFAAoF;AACpF,MAAM,MAAM,wBAAwB,GAAG,cAAc,CAAA;AAErD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,kBAAkB,EAAE,EAC/B,OAAO,GAAE,wBAA6B,GACrC,MAAM,CAIR"}

package/dist/adapters/http/ExpressAdapter.js

@@ -0,0 +1,109 @@
+import { Router } from 'express';
+import { registerCrudApi } from '../../core/crudRouter.js';
+/**
+ * Casts Express's header map to Halifax's `Record<string, string | string[] | undefined>` type.
+ * Express guarantees header names are lowercase and values are strings or string arrays,
+ * so this cast is safe.
+ * @param headers - The raw headers object from an Express `Request`.
+ * @returns The same object typed as Halifax's header record.
+ */
+function normalizeHeaders(headers) {
+    return headers;
+}
+/**
+ * Wraps an Express `Request` in Halifax's framework-agnostic {@link HttpRequest}.
+ * @param req - The Express request to adapt.
+ * @returns A Halifax-compatible {@link HttpRequest} with the original request in `raw`.
+ */
+function adaptRequest(req) {
+    return {
+        method: req.method,
+        params: req.params,
+        query: req.query,
+        body: req.body,
+        headers: normalizeHeaders(req.headers),
+        raw: req
+    };
+}
+/**
+ * Wraps an Express `Response` in Halifax's framework-agnostic {@link HttpResponse}.
+ * @param res - The Express response to adapt.
+ * @returns A Halifax-compatible {@link HttpResponse} with the original response in `raw`.
+ */
+function adaptResponse(res) {
+    return {
+        raw: res,
+        status(code) {
+            res.status(code);
+            return this;
+        },
+        json(payload) {
+            res.json(payload);
+        },
+        send(payload) {
+            res.send(payload);
+        },
+        setHeader(name, value) {
+            res.setHeader(name, value);
+        }
+    };
+}
+/** Adapts an Express `App` or `Router` to Halifax's {@link HttpServer} interface. */
+export class ExpressHttpServer {
+    app;
+    /**
+     * @param app - Express application or router to register routes on.
+     *   When an `App` is provided, `start()` will call `listen()`.
+     *   When a `Router` is provided, `start()` is a no-op.
+     */
+    constructor(app) {
+        this.app = app;
+    }
+    /**
+     * Registers a route on the Express app for the given method and path.
+     * @param method - HTTP method (or `'*'` to register a catch-all via `app.all`).
+     * @param path - Route path pattern (e.g. `'/users/:id'`).
+     * @param handler - Halifax route handler to invoke on matching requests.
+     */
+    registerRoute(method, path, handler) {
+        const cb = (req, res) => {
+            void Promise.resolve(handler(adaptRequest(req), adaptResponse(res)));
+        };
+        if (method === '*') {
+            ;
+            this.app.all(path, cb);
+            return;
+        }
+        ;
+        this.app[method.toLowerCase()](path, cb);
+    }
+    /**
+     * Starts the Express server. No-op when the underlying app does not expose a `listen` method
+     * (e.g. when `app` is a `Router` mounted on an existing Express app).
+     * @param port - TCP port number to bind to.
+     * @param host - Hostname or IP address to bind to (defaults to all interfaces when omitted).
+     */
+    async start(port, host) {
+        await new Promise((resolve) => {
+            if ('listen' in this.app && typeof this.app.listen === 'function') {
+                ;
+                this.app.listen(port, host, () => resolve());
+                return;
+            }
+            resolve();
+        });
+    }
+}
+/**
+ * Creates a fully-wired Express `Router` with CRUD routes for every resource.
+ *
+ * @param resources - Resource definitions to register (use {@link createPrismaResources} to generate these).
+ * @param options - Auth strategy, query-builder path overrides, etc.
+ * @returns An Express `Router` ready to mount with `app.use('/api', router)`.
+ */
+export function createExpressCrudRouter(resources, options = {}) {
+    const router = Router();
+    registerCrudApi(new ExpressHttpServer(router), resources, options);
+    return router;
+}
+//# sourceMappingURL=ExpressAdapter.js.map

package/dist/adapters/http/ExpressAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpressAdapter.js","sourceRoot":"","sources":["../../../src/adapters/http/ExpressAdapter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAQhC,OAAO,EAAE,eAAe,EAAuB,MAAM,sBAAsB,CAAA;AAG3E;;;;;;GAMG;AACH,SAAS,gBAAgB,CACvB,OAA2B;IAE3B,OAAO,OAAwD,CAAA;AACjE,CAAC;AAED;;;;GAIG;AACH,SAAS,YAAY,CAAC,GAAY;IAChC,OAAO;QACL,MAAM,EAAE,GAAG,CAAC,MAAM;QAClB,MAAM,EAAE,GAAG,CAAC,MAAgC;QAC5C,KAAK,EAAE,GAAG,CAAC,KAAgC;QAC3C,IAAI,EAAE,GAAG,CAAC,IAAI;QACd,OAAO,EAAE,gBAAgB,CAAC,GAAG,CAAC,OAAO,CAAC;QACtC,GAAG,EAAE,GAAG;KACT,CAAA;AACH,CAAC;AAED;;;;GAIG;AACH,SAAS,aAAa,CAAC,GAAa;IAClC,OAAO;QACL,GAAG,EAAE,GAAG;QACR,MAAM,CAAC,IAAY;YACjB,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;YAChB,OAAO,IAAI,CAAA;QACb,CAAC;QACD,IAAI,CAAC,OAAgB;YACnB,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;QACnB,CAAC;QACD,IAAI,CAAC,OAAiB;YACpB,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;QACnB,CAAC;QACD,SAAS,CAAC,IAAY,EAAE,KAAa;YACnC,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,KAAK,CAAC,CAAA;QAC5B,CAAC;KACF,CAAA;AACH,CAAC;AAED,qFAAqF;AACrF,MAAM,OAAO,iBAAiB;IAMQ;IALpC;;;;OAIG;IACH,YAAoC,GAAqB;QAArB,QAAG,GAAH,GAAG,CAAkB;IAAG,CAAC;IAE7D;;;;;OAKG;IACI,aAAa,CAAC,MAAkB,EAAE,IAAY,EAAE,OAAyB;QAC9E,MAAM,EAAE,GAAG,CAAC,GAAY,EAAE,GAAa,EAAE,EAAE;YACzC,KAAK,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,CAAA;QACtE,CAAC,CAAA;QACD,IAAI,MAAM,KAAK,GAAG,EAAE,CAAC;YACnB,CAAC;YAAC,IAAI,CAAC,GAAW,CAAC,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC,CAAA;YAChC,OAAM;QACR,CAAC;QACD,CAAC;QAAC,IAAI,CAAC,GAAW,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAA;IACpD,CAAC;IAED;;;;;OAKG;IACI,KAAK,CAAC,KAAK,CAAC,IAAY,EAAE,IAAa;QAC5C,MAAM,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;YAClC,IAAI,QAAQ,IAAI,IAAI,CAAC,GAAG,IAAI,OAAO,IAAI,CAAC,GAAG,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;gBAClE,CAAC;gBAAC,IAAI,CAAC,GAAW,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,OAAO,EAAE,CAAC,CAAA;gBACtD,OAAM;YACR,CAAC;YACD,OAAO,EAAE,CAAA;QACX,CAAC,CAAC,CAAA;IACJ,CAAC;CACF;AAKD;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB,CACrC,SAA+B,EAC/B,UAAoC,EAAE;IAEtC,MAAM,MAAM,GAAG,MAAM,EAAE,CAAA;IACvB,eAAe,CAAC,IAAI,iBAAiB,CAAC,MAAM,CAAC,EAAE,SAAS,EAAE,OAAO,CAAC,CAAA;IAClE,OAAO,MAAM,CAAA;AACf,CAAC"}