gina 0.5.6 → 0.5.7

package/CHANGELOG.md

@@ -6,6 +6,23 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html),
 and is generated by [Changie](https://github.com/miniscruff/changie).
 
 
+## 0.5.7 - 2026-07-03
+### Added
+* Added a connector-backed job store to the async-job primitive: point `jobs.store` (app.json) at a `connectors.json` entry and job records persist in SQLite (`node:sqlite` built-in, zero new dependencies) — they survive bundle restarts and are readable cross-process, while the deferred function still runs in the creating process. A configured store that cannot be built fails the boot instead of silently degrading to the in-memory store, and the create/worker race on async stores was hardened away for future backends.
+* Added a MongoDB backend for the connector-backed job store: point `jobs.store` (app.json) at a `connectors.json` entry with `"connector": "mongodb"` (same `uri`/`host`/`database` keys as the MongoDB session store; the driver is resolved from the consuming project `node_modules`) and job records live on a shared mongod — restart-durable and visible across processes and pods, while the deferred function still runs in the creating process. Expiry stays sweep-driven for parity with the other stores: no server-side TTL reaping.
+* Added a Redis backend for the connector-backed job store: point `jobs.store` (app.json) at a `connectors.json` entry with `"connector": "redis"` (same `host`/`port`/`db`/`password`/`tls`/`cluster` keys as the Redis session store; driver `ioredis`, resolved like the session store with a project `node_modules` fallback) and job records live on a shared Redis — restart-durable and visible across processes and pods, while the deferred function still runs in the creating process. Records carry per-state and expiry indexes maintained atomically (MULTI) so list and sweep never scan the keyspace, and expiry stays sweep-driven for parity with the other stores: no per-key TTL. Redis Cluster is supported via a hash-tagged key prefix (default `{jobs}:`).
+* Failed async jobs can now retry: pass `maxAttempts` to `self.startJob` / `lib.job.create` and a failed attempt is retried on the creating process with exponential backoff (`jobs.retryBackoffMs` in app.json, default 1000 ms, doubling per attempt). Between attempts the record returns to `pending` with the last error and a `nextRetryAt` timestamp visible, and it cannot be purged by the TTL sweep; `failed` and `completed` remain strictly terminal, and the completion webhook fires exactly once, after the final attempt. The default stays a single attempt — behavior is unchanged unless you opt in.
+### Changed
+* npm 12 readiness for the install and release tooling: the prepack leak scan and the smoke harness accept the object-keyed `npm pack --json` output of npm 12 (npm <= 11 array output unchanged), the leak scan fails closed on unrecognized shapes instead of passing vacuously, the container smoke opts tarball install scripts back in under the npm 12 allow-scripts default, and the README documents installing with `--allow-scripts=gina` on npm 12+
+### Fixed
+* A `connectors.json` entry with `"connector": "redis"` no longer aborts the bundle boot. The model layer loads a `lib/connector.js` for every declared connector and treated the Redis connector's missing one as fatal — so even the documented Redis session-store configuration could not boot with its entry declared. The Redis connector now ships a no-op boot connector that opens no connection and requires no driver.
+* Fixed a production-mode HTTP 500 on every swig-rendered route carrying a cache setting in routing.json: the render cache writer referenced render()-scoped state from module scope (ReferenceError: self is not defined); the cache flag and error reporter are now threaded into writeCache as parameters
+* Fixed a cross-request data bleed in the swig render delegate under production concurrency: per-request helpers (the template-data getter, resource injector and layout-cache path) were captured at module scope, so a render suspended at the template-read await could resume with a concurrent request's closures and merge that request's page data into its own response. All per-request dependencies are now function-scoped inside render().
+* Fixed two cross-request defects in the streaming render delegate under production concurrency: a finishing stream released a concurrent request's req/res refs mid-stream instead of its own (leaving its own unreleased), and a stream error was reported through the concurrent request's controller. The per-request dependencies are now function-scoped.
+* Fixed the JSON render delegate's cache writer reporting a cache-configuration error through a concurrent request's controller under production concurrency: the module-level writeCache resumed after its file-write await reading the module-scoped controller reference, which any renderJSON entering during the suspension had reassigned. Every render-scoped value is now threaded into writeCache as a parameter and the delegate's per-request dependencies are function-scoped.
+### Security
+* Fixed a path-traversal vulnerability in the static-asset resolver: a request URL containing `../` — or its `%2F` / `%2e%2e` percent-encoded forms — could escape a `statics.json` mapping's target directory and read any sibling file under the shared root (configuration, credentials, or server-side source). Both static resolvers now canonicalise the resolved path and confine it to its mapping target (or `publicPath`), returning 404 on any escape; legitimate assets are served unchanged and no configuration change is required.
+
 ## 0.5.6 - 2026-07-01
 ### Added
 * Added a streaming variant to the AI connector: getModel('<name>').stream(messages, options) returns an EventEmitter emitting start/delta/done/error events for token-by-token inference, plus an .onComplete(cb) shim mirroring infer(). Works across Anthropic and every OpenAI-compatible provider; the buffered infer() is unchanged.

package/README.md

@@ -40,13 +40,16 @@ gina bundle:start api @myproject
 open https://localhost:3100
 ```
 
-## What's in 0.5.6
+> **npm 12+** blocks install scripts by default, and gina's post-install bootstraps `~/.gina` and the framework dependencies. Install with `npm install -g gina@latest --allow-scripts=gina`, or allow it once for all global installs with `npm config set allow-scripts=gina --location=user`. (Not needed on npm ≤ 11.)
 
-- **AI-connector CLI suite.** `gina connector:infer <connector> @<project> --message="…"` runs a one-off inference against a configured AI connector **outside a running bundle** — resolves the merged connector config + `${secret:KEY}` credentials (never echoed), instantiates the connector directly, and prints the normalised result. `--stream` emits token frames as NDJSON, `--raw` adds the full provider response, `--format=json` for machine output. `gina connector:test [<connector>] @<project>` probes connectors for readiness (driver installed, `${secret:KEY}` resolvable), exits non-zero on any failure (CI-friendly); `--connect` adds a zero-generation-token live provider check.
-- **Streaming AI inference.** `getModel('<name>').stream(messages, options)` returns an EventEmitter emitting `start` / `delta` / `done` / `error` for token-by-token inference across Anthropic and every OpenAI-compatible provider (plus an `.onComplete(cb)` shim); the buffered `infer()` is unchanged.
-- **AI stream + application events in the Inspector.** A new dev-Inspector **"AI stream"** tab shows token streams per request; a new **"Events"** tab surfaces named application events emitted with `self.emitEvent(name, metadata)`, with opt-in bridges (`settings.inspector.events.topics`) that surface whitelisted entity events and database connector-lifecycle (`<connector>#ready`) events.
-- **`getModel()` exposes the AI inference API.** `getModel(name).infer(…)` and `getModel(name).stream(…)` now work as documented — previously an AI connector returned only a bare connection wrapper.
-- **Robustness fixes.** Boot aborts with a clear message on a model-init failure instead of starting degraded (#B57); a corrupt `~/.gina/projects.json` registration is skipped with a warning instead of crashing every command (#B59); DELETE-route requirement regexes honour their flags and no longer crash on a group-close-before-flag pattern; multipart upload filenames with non-ASCII UTF-8 characters are decoded correctly; a native `<dialog>` popin closed by the user agent (Escape / dialog-method form) runs the same cleanup as the close button; the Couchbase connector substitutes a positional placeholder used as a dynamic field-path key at every occurrence; `gina project:import` is now additive across release targets; `gina stop` reports any bundles still running.
+## What's in 0.5.7
+
+- **Durable async-job stores.** The async-job primitive (`self.startJob` / `lib.job`) can now persist job records in a real backend: point `jobs.store` (app.json) at a `connectors.json` entry and records survive bundle restarts and are readable cross-process — **SQLite** (`node:sqlite` built-in, zero new dependencies), **MongoDB** (shared mongod — durable and visible across processes and pods), or **Redis** (`ioredis`; per-state and expiry indexes maintained atomically so list and sweep never scan the keyspace; Redis Cluster supported via a hash-tagged key prefix). A configured store that cannot be built fails the boot instead of silently degrading to the in-memory store.
+- **Failed-job retry (opt-in).** Pass `maxAttempts` to `self.startJob` / `lib.job.create` and a failed attempt is retried on the creating process with exponential backoff (`jobs.retryBackoffMs` in app.json, default 1000 ms, doubling per attempt). Between attempts the record returns to `pending` with the last error and a `nextRetryAt` timestamp visible; `failed` and `completed` remain strictly terminal, and the completion webhook fires exactly once. The default stays a single attempt — behavior is unchanged unless you opt in.
+- **npm 12 readiness.** The install and release tooling accept npm 12's changed `npm pack --json` output shape, and installing under npm 12's script-blocking default is documented (`npm install -g gina@latest --allow-scripts=gina` — not needed on npm ≤ 11).
+- **Concurrency fixes in the render delegates.** A family of cross-request defects under production concurrency: the swig render cache writer crashed with an HTTP 500 on every cached route in production (#B60); a swig render suspended at its template-read await could resume with a concurrent request's closures and merge that request's page data into its own response (#B61); a finishing stream released a concurrent request's `req`/`res` refs instead of its own and reported stream errors through the wrong controller (#B62); the JSON delegate's cache writer reported cache-configuration errors through a concurrent request's controller (#B63). All per-request state in the delegates is now function-scoped.
+- **Robustness fixes.** A `connectors.json` entry with `"connector": "redis"` no longer aborts the bundle boot — the Redis connector now ships a no-op boot connector, unblocking the documented Redis session-store configuration.
+- **Security — static-asset path traversal fixed.** A request URL with `../` (or its `%2F` / `%2e%2e` percent-encoded forms) could escape a `statics.json` mapping's target directory and read any sibling file under the shared root (config, credentials, server-side source). Both static resolvers now confine the resolved path to its mapping target (or `publicPath`) and return 404 on any escape (#B64); legitimate assets are unaffected and no configuration change is required.
 
 See the full [Changelog](./CHANGELOG.md) and [Roadmap](./ROADMAP.md).
 

package/ROADMAP.md

@@ -31,6 +31,7 @@ This roadmap covers planned features, architectural improvements, new connectors
 | **Q2 2026** | `0.5.4` ✅ | Node.js 26 support (engine `>= 22 <27`, CI matrix) · FormValidator fixes (`isFloat` accepts string floats · `isDate` non-ISO masks + rule chaining) · quieter live form validation (error message revealed on blur) · file-upload fixes (honour `tmpPath` / per-group `path` · enforce `maxFields` + `maxFieldsSize` unit suffix · **Security**: reject uploads to an unconfigured group, closing an `allowedExtensions` / `isMultipleAllowed` bypass) · two dev-mode heap fixes (hot-reload lib-eviction leak · HTTP/2 `self.query()` settled-stream retention) · tighter per-request config isolation (narrowed router clone · `getRouteByUrl` shared-config mutation) · dev Inspector reliability (per-tab channel under COOP · Swig render-race isolation · multi-bundle proxy log/index routing · SPA hardening) · Express-engine `/_gina/info` + `/_gina/cache/stats` parity · `bundle:add --ignore-ports` |
 | **Q2 2026** | `0.5.5` ✅ | WebSocket routes in `routing.json` (`method: "ws"` + `param.wsHandler` → `channels/<name>.js`, `:param` paths, per-route `param.wsOptions`) · cross-bundle `session.query()` from WebSocket channel handlers · framework version side-by-side CLI (`framework:add` / `framework:list` / `framework:remove` / `framework:update` / `framework:reset`) · `project:move` / `project:backup` / `project:restore` · inline CLI man pages (`framework:man` / `project:man` / `bundle:man` / `service:man`) · Bun promoted to a supported, CI-gated runtime · idempotent HTTP/2 client retries (safe-method gating + per-call `retryUnsafe` opt-in) · **Security**: WebSocket-DoS dependency hardening (`ws` override) · `tail` restart hardening |
 | **Q3 2026** | `0.5.6` ✅ | AI-connector CLI suite — `connector:infer` (one-off inference · `--stream` NDJSON · `--raw`) + `connector:test` (CI readiness probe · `--connect` zero-token live check) · AI connector `stream()` + Inspector "AI stream" tab · application events in the Inspector — `self.emitEvent()` + a new "Events" tab, opt-in entity-event & connector-lifecycle bridges · `getModel()` exposes the AI `infer`/`stream` API · fixes: model-init fail-fast · corrupt `projects.json` registration skipped cleanly · DELETE-route regex flags + off-by-one crash · UTF-8 multipart upload filenames · native `<dialog>` popin close cleanup · Couchbase dynamic field-path placeholder · `project:import` additive across release targets · `gina stop` bundles-still-running notice |
+| **Q3 2026** | `0.5.7` ✅ | Durable async-job stores — `jobs.store` (app.json) → `connectors.json` entry: SQLite (`node:sqlite`, zero new dependencies) · MongoDB (shared mongod, multi-pod) · Redis (`ioredis`, atomic per-state + expiry indexes, Redis Cluster via hash-tagged prefix); restart-durable, cross-process, fail-fast on an unbuildable store · opt-in failed-job retry (`maxAttempts` + exponential backoff; completion webhook fires exactly once) · npm 12 readiness (install + release tooling, `--allow-scripts=gina` guidance) · render-delegate concurrency fixes (production cross-request data bleed / wrong-controller error routing / cached-route 500) · `"connector": "redis"` entry no longer aborts boot · **Security**: static-asset path-traversal fix — resolver paths canonicalised and confined to their `statics.json` mapping target (404 on any escape, `%2F` / `%2e%2e` forms included) |
 | **Q1 2027** | `0.5.x` | HTTP/2 priorities (blocked on Node scheduler hooks) · Beemaster admin + visual translation editor |
 | **Q3 2027** | `1.0.0` | First stable release — Windows alpha compatibility is a hard gate |
 

package/framework/v0.5.7/VERSION

@@ -0,0 +1 @@
+0.5.7

package/framework/v0.5.7/core/connectors/mongodb/lib/job-store.js

@@ -0,0 +1,334 @@
+/*
+ * This file is part of the gina package.
+ * Copyright (c) 2009-2026 Rhinostone <contact@gina.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+'use strict';
+
+/**
+ * @module gina/core/connectors/mongodb/job-store
+ *
+ * MongoDB-backed `JobStore` for the async-job primitive (`lib/job`) — the
+ * second connector store of the #AI6 family (SQLite shipped first). Backed by
+ * the consumer project's own `mongodb` driver, resolved from the project's
+ * `node_modules` exactly like the MongoDB session store — the framework keeps
+ * zero hard dependency on it.
+ *
+ * What it buys over the SQLite store: the record lives on a mongod every pod
+ * can reach, so this is the true multi-pod backend — a job created on pod A is
+ * pollable from pod B via `/_gina/jobs/:id`, and records survive any single
+ * bundle restart. The deferred *function* still runs only in the process that
+ * created the job — the store shares the record, never the closure (see
+ * `lib/job`).
+ *
+ * Deliberate divergences from the MongoDB SESSION store (same connector,
+ * different contract):
+ *   - `get` / `list` do NOT filter on expiry. The memory store returns
+ *     terminal records until `sweep` purges them, and behavioral parity with
+ *     the memory store is the contract here — expiry acts only at sweep time.
+ *   - NO server-side TTL index. Mongo's TTL monitor is a Date-indexed reaper
+ *     that would purge records OUTSIDE the seam's sweep (breaking the parity
+ *     above) — and the job record's `expiresAt` is an epoch-ms NUMBER, which
+ *     the TTL monitor ignores anyway (it only reaps BSON Date fields), so a
+ *     TTL index here would look configured while silently never firing. The
+ *     two secondary indexes created at construction (`jobsState`,
+ *     `jobsExpires`) are plain performance indexes with no reaping semantics.
+ *   - The record is stored as a JSON STRING (the session store's `sess`
+ *     precedent), not a nested document: caller-supplied `meta` may carry
+ *     dotted or dollar-prefixed keys that BSON documents reject, and the
+ *     JSON round-trip is exactly the fidelity the seam guarantees.
+ *
+ * Config keys follow the mongodb connector's OWN conventions (the §11 rule —
+ * mirrors the session store's URI assembly): `uri` preferred, else
+ * host/port/username/password/database/authSource/replicaSet + ssl. For
+ * mongodb, `database` is a NAME (the same field the model layer's entity scan
+ * reads), so the connectors.json entry is model-scan-compatible by
+ * construction — the sqlite `file`-as-path quirk does not apply here.
+ *
+ * Constructed by the `lib/job-store` dispatcher at boot; not meant to be
+ * instantiated from application code.
+ */
+
+/**
+ * Job lifecycle states — imported so the sweep predicate can never drift from
+ * the memory store's (`lib/job` is a plain-required module-singleton; there is
+ * no load-time cycle because `lib/job` never requires this file — the
+ * `lib/job-store` dispatcher requires it lazily at boot).
+ *
+ * @inner
+ * @type {{PENDING:string, RUNNING:string, COMPLETED:string, FAILED:string}}
+ */
+var STATES = require('../../../../lib/job/src/main').STATES;
+
+/**
+ * No-op callback used when a caller omits one.
+ * @inner
+ * @returns {void}
+ */
+function noop() {}
+
+/**
+ * Build a MongoDB-backed job store implementing the `lib/job` `JobStore` seam
+ * (`set / get / remove / list / sweep`, all Node-callback-shaped). The driver
+ * is promise-based, so callbacks fire asynchronously — `lib/job`'s create-race
+ * hardening (drain scheduled inside the `set` callback) is what makes an async
+ * store safe as a drop-in.
+ *
+ * Each record is stored as `{ _id, state, expiresAt, updatedAt, record }`:
+ * thin indexed fields for the two query shapes (list-by-state,
+ * sweep-by-expiry) — mirroring the SQLite store's columns — with the full
+ * record riding as a JSON string because it legitimately gains keys after
+ * creation (`webhookDeliveredAt`, `webhookFailed`, ...). All timestamps are
+ * epoch MILLISECONDS — the seam's unit (`sweep(now)` receives `Date.now()`;
+ * the session store's Date-typed `expiresAt` convention does NOT apply).
+ *
+ * @param {object}  connConf              - Resolved `connectors.json` entry for this store.
+ * @param {string}  [connConf.uri]        - Full mongodb:// or mongodb+srv:// URI (preferred).
+ * @param {string}  [connConf.host]       - Single host (used when uri absent; default 127.0.0.1).
+ * @param {number}  [connConf.port]       - Single port (default 27017).
+ * @param {string}  [connConf.username]   - Auth username.
+ * @param {string}  [connConf.password]   - Auth password.
+ * @param {string}  connConf.database     - Database NAME (required — the mongodb connector's
+ *                                          own convention; the model layer reads the same field).
+ * @param {string}  [connConf.authSource] - Auth db (typically "admin").
+ * @param {string}  [connConf.replicaSet] - Replica set name.
+ * @param {object|boolean} [connConf.ssl] - TLS configuration (true, or a driver options object).
+ * @param {string}  [connConf.collection] - Jobs collection (default 'jobs').
+ * @param {string}  bundle                - Bundle name — used in log lines.
+ * @param {object}  [injected]            - Test-only dependency injection (the entity-layer
+ *                                          `injected` precedent): `{ driver }` replaces the
+ *                                          project-resolved mongodb module. The dispatcher
+ *                                          always calls with two arguments.
+ * @returns {object}                      - A `JobStore` instance, plus a `close()` convenience
+ *                                          (not part of the seam; releases the client).
+ * @throws {Error}                        - When the mongodb driver is not installed in the
+ *                                          project, or `database` is missing.
+ *
+ * @example
+ *   // connectors.json:  { "jobsDb": { "connector": "mongodb", "host": "127.0.0.1",
+ *   //                                 "port": 27017, "database": "gina_jobs" } }
+ *   // app.json:         { "jobs": { "store": "jobsDb" } }
+ *   // (wired automatically at boot by gna.js via lib/job-store)
+ */
+module.exports = function MongodbJobStore(connConf, bundle, injected) {
+    connConf = connConf || {};
+
+    // Resolve the mongodb driver from the project's node_modules (session-store
+    // precedent) so the framework has zero hard dependency on it. The injected
+    // branch is test-only; the default branch is the only place the injected
+    // `_` / `getPath` globals are read, so tests stay standalone.
+    var mongodb;
+    if (injected && injected.driver) {
+        mongodb = injected.driver;
+    } else {
+        try {
+            var driverPath = _(getPath('project') + '/node_modules/mongodb', true);
+            mongodb = require(driverPath);
+        } catch (e) {
+            throw new Error(
+                '[MongodbJobStore] mongodb is not installed. '
+                + 'Run `npm install mongodb` in your project.\n'
+                + e.message
+            );
+        }
+    }
+
+    var dbName = connConf.database;
+    if (!dbName) {
+        throw new Error('[MongodbJobStore] missing required `database` field in the connectors.json entry');
+    }
+
+    // Compose the connection URI — mirrors the session store's resolveUri()
+    // (itself mirroring core/connectors/mongodb/lib/connector.js).
+    var uri = connConf.uri;
+    if (!uri) {
+        var host       = connConf.host || '127.0.0.1';
+        var port       = connConf.port || 27017;
+        var username   = connConf.username;
+        var password   = connConf.password;
+        var authSource = connConf.authSource;
+        var replicaSet = connConf.replicaSet;
+
+        var auth = '';
+        if (username) {
+            auth = encodeURIComponent(username);
+            if (password) auth += ':' + encodeURIComponent(password);
+            auth += '@';
+        }
+        uri = 'mongodb://' + auth + host + ':' + port + '/' + encodeURIComponent(dbName);
+        var qs = [];
+        if (authSource) qs.push('authSource=' + encodeURIComponent(authSource));
+        if (replicaSet) qs.push('replicaSet=' + encodeURIComponent(replicaSet));
+        if (qs.length) uri += '?' + qs.join('&');
+    }
+
+    var clientOptions = {};
+    var ssl           = connConf.ssl;
+    if (ssl === true) {
+        clientOptions.tls = true;
+    } else if (ssl && typeof ssl === 'object') {
+        clientOptions.tls = true;
+        for (var k in ssl) {
+            if (Object.prototype.hasOwnProperty.call(ssl, k)) {
+                clientOptions[k] = ssl[k];
+            }
+        }
+    }
+
+    var collectionName = connConf.collection || 'jobs';
+    var client         = new mongodb.MongoClient(uri, clientOptions);
+    var coll           = client.db(dbName).collection(collectionName);
+
+    // Eager connect + plain secondary indexes, fire-and-forget: operations
+    // never wait on this (the driver queues them until connected, and index
+    // existence is a pure performance concern — no behavioral role). A failure
+    // is logged; each subsequent operation then surfaces its own driver error
+    // through the seam callbacks.
+    client.connect().then(function() {
+        return Promise.all([
+            coll.createIndex({ state: 1 },     { name: 'jobsState' }),
+            coll.createIndex({ expiresAt: 1 }, { name: 'jobsExpires' })
+        ]);
+    }).catch(function(err) {
+        console.error('[MongodbJobStore] connection/index setup failed (bundle: '
+            + bundle + '): ' + ((err && err.message) || err));
+    });
+
+    return {
+
+        /**
+         * Upsert `record` under `id`. The record is serialised whole into the
+         * `record` JSON-string field; `state` and `expiresAt` are additionally
+         * mirrored into their indexed fields. The driver result is never
+         * forwarded to the callback (a resolved UpdateResult in the err slot
+         * is the classic express-session-store bug) — `fn(null, record)`
+         * explicitly on success.
+         *
+         * @param {string}    id
+         * @param {JobRecord} record
+         * @param {function}  [fn] - `fn(err, record)`.
+         * @returns {void}
+         */
+        set: function(id, record, fn) {
+            if (typeof fn !== 'function') fn = noop;
+            var json;
+            try {
+                json = JSON.stringify(record);
+            } catch (err) {
+                return fn(err);
+            }
+            var doc = {
+                _id:       id,
+                state:     String(record.state || ''),
+                expiresAt: (typeof record.expiresAt === 'number') ? record.expiresAt : null,
+                updatedAt: (typeof record.updatedAt === 'number') ? record.updatedAt : Date.now(),
+                record:    json
+            };
+            coll.replaceOne({ _id: id }, doc, { upsert: true })
+                .then(function() { fn(null, record); })
+                .catch(function(err) { fn(err); });
+        },
+
+        /**
+         * Fetch a record by `id`. No expiry filter — a terminal record past its
+         * `expiresAt` stays readable until `sweep` purges it (memory-store
+         * parity; the session store's lag-protection filter does NOT apply).
+         *
+         * @param {string}   id
+         * @param {function} fn - `fn(err, record|null)`.
+         * @returns {void}
+         */
+        get: function(id, fn) {
+            if (typeof fn !== 'function') fn = noop;
+            coll.findOne({ _id: id }).then(function(doc) {
+                if (!doc) return fn(null, null);
+                var rec;
+                try {
+                    rec = JSON.parse(doc.record);
+                } catch (parseErr) {
+                    return fn(new Error('[MongodbJobStore] could not parse job record `' + id + '`: ' + parseErr.message));
+                }
+                fn(null, rec);
+            }).catch(function(err) {
+                fn(err);
+            });
+        },
+
+        /**
+         * Delete a record by `id`.
+         *
+         * @param {string}   id
+         * @param {function} [fn] - `fn(err, existed)`.
+         * @returns {void}
+         */
+        remove: function(id, fn) {
+            if (typeof fn !== 'function') fn = noop;
+            coll.deleteOne({ _id: id })
+                .then(function(res) { fn(null, !!(res && res.deletedCount > 0)); })
+                .catch(function(err) { fn(err); });
+        },
+
+        /**
+         * List records, optionally filtered by `{ state }`. No expiry filter
+         * (memory-store parity). A record that fails to parse fails the whole
+         * list loudly — silent skipping would hide corruption.
+         *
+         * @param {?Object}  filter - e.g. `{ state: 'failed' }`; `null` for all.
+         * @param {function} fn     - `fn(err, records)`.
+         * @returns {void}
+         */
+        list: function(filter, fn) {
+            if (typeof fn !== 'function') fn = noop;
+            var query = (filter && filter.state) ? { state: String(filter.state) } : {};
+            coll.find(query).toArray().then(function(docs) {
+                var out = [];
+                try {
+                    for (var i = 0; i < docs.length; i++) {
+                        out.push(JSON.parse(docs[i].record));
+                    }
+                } catch (parseErr) {
+                    return fn(new Error('[MongodbJobStore] could not parse a job record while listing: ' + parseErr.message));
+                }
+                fn(null, out);
+            }).catch(function(err) {
+                fn(err);
+            });
+        },
+
+        /**
+         * Purge terminal (`completed` / `failed`) records whose `expiresAt` has
+         * elapsed — the exact memory-store predicate, expressed as one
+         * deleteMany. BSON type bracketing makes the `$lte` bound match numeric
+         * `expiresAt` values only, so null / absent `expiresAt` records are
+         * excluded server-side (the SQLite store's `IS NOT NULL` clause,
+         * for free).
+         *
+         * @param {number}   now - Epoch ms (passed in by `lib/job`).
+         * @param {function} fn  - `fn(err, removedCount)`.
+         * @returns {void}
+         */
+        sweep: function(now, fn) {
+            if (typeof fn !== 'function') fn = noop;
+            coll.deleteMany({
+                state:     { $in: [STATES.COMPLETED, STATES.FAILED] },
+                expiresAt: { $lte: now }
+            }).then(function(res) { fn(null, (res && res.deletedCount) || 0); })
+              .catch(function(err) { fn(err); });
+        },
+
+        /**
+         * Release the underlying MongoClient. NOT part of the `JobStore` seam —
+         * `lib/job` never calls it; provided for tests and explicit teardown.
+         *
+         * @returns {void}
+         */
+        close: function() {
+            try {
+                var p = client.close();
+                if (p && typeof p.catch === 'function') p.catch(noop);
+            } catch (e) { /* already closed */ }
+        }
+    };
+};

package/framework/v0.5.7/core/connectors/redis/index.js

@@ -0,0 +1,36 @@
+/*
+ * This file is part of the gina package.
+ * Copyright (c) 2009-2026 Rhinostone <contact@gina.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+'use strict';
+
+/**
+ * Redis connector — v1: session store + job store (no entity/ORM wiring).
+ *
+ * Entity/ORM wiring is not implemented in v1. Use this connector as:
+ *   - a session store backend via `lib.SessionStore`
+ *     (see: core/connectors/redis/lib/session-store.js), or
+ *   - an async-job store backend via `app.json`'s `jobs.store`
+ *     (see: core/connectors/redis/lib/job-store.js).
+ *
+ * To configure:
+ *   1. Add a `redis` entry to `config/connectors.json` in your bundle.
+ *   2. Install ioredis in your project: `npm install ioredis`
+ *   3. Wire the store: session store in `bundle/index.js`, job store via
+ *      `app.json` `{ "jobs": { "store": "<entry name>" } }`.
+ *
+ * The boot-time model scan is satisfied by the no-op `lib/connector.js`
+ * (no connection is opened at boot — each store owns its client).
+ * ORM / entity support is planned for a future release.
+ *
+ * @class Redis
+ * @constructor
+ */
+var Redis = function Redis() {
+    // v1: no entity wiring — session store + job store only
+};
+
+module.exports = Redis;

package/framework/v0.5.7/core/connectors/redis/lib/connector.js

@@ -0,0 +1,66 @@
+/*
+ * This file is part of the gina package.
+ * Copyright (c) 2009-2026 Rhinostone <contact@gina.io>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+'use strict';
+
+var EventEmitter = require('events').EventEmitter;
+var util         = require('util');
+
+/**
+ * Redis connector — no-op boot-scan satisfier (v1: no entity/ORM wiring).
+ *
+ * The model layer (`lib/model.js` -> `core/model/index.js`) loads
+ * `core/connectors/<type>/lib/connector.js` for EVERY `connectors.json` entry
+ * at bundle boot and treats a missing file as fatal (`model#ready` fires with
+ * an Error and the boot exits). Before this file existed, ANY redis entry —
+ * including the documented session-store configuration and a job-store entry —
+ * aborted the boot at that scan.
+ *
+ * This connector therefore exists to let a redis entry pass the scan; it
+ * deliberately:
+ *   - opens NO connection (the redis session store and job store each build
+ *     and own their own client — nothing at boot needs one);
+ *   - requires NO driver (the entry must boot even before the driver package
+ *     is installed; the stores resolve the driver themselves at their own
+ *     construction time, with an actionable error);
+ *   - reports ready synchronously with a `null` connection (the sqlite
+ *     connector's sync-`onReady` precedent — there is no handshake to wait on).
+ *
+ * Entity/ORM support remains unimplemented for redis: `getModel()` on a redis
+ * entry yields only the bare `{ _connection: null, getConnection }` shell the
+ * model layer builds — by design, until a redis ORM lands.
+ *
+ * @class RedisConnector
+ * @constructor
+ * @param {object} conf - Connector config from connectors.json (kept for
+ *                        API parity with real connectors; nothing is read).
+ */
+function RedisConnector(conf) {
+    EventEmitter.call(this);
+
+    /**
+     * The connectors.json entry, exposed for introspection/debugging only.
+     * @type {object}
+     */
+    this.conf = conf || {};
+
+    /**
+     * Register a one-time ready callback.
+     * Fires synchronously (sqlite precedent) with a `null` connection —
+     * nothing is dialled at boot; the session/job stores own their clients.
+     *
+     * @param {function} fn - `fn(err, conn)`; always called as `fn(null, null)`.
+     * @returns {void}
+     */
+    this.onReady = function(fn) {
+        fn(null, null);
+    };
+}
+
+util.inherits(RedisConnector, EventEmitter);
+
+module.exports = RedisConnector;