@fougere/adapter-memory 0.6.0-alpha.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,50 @@
+# @fougere/adapter-memory
+
+> Rows in a Map — the source that ships no driver
+
+What an app with no `db` runs on, and what a test runs on when the shape is the subject
+and the engine is not.
+
+```ts
+// fougere.config.ts
+export default defineFougere({
+  db: { source: 'memory' },
+  sources: { cache: { source: 'memory', entities: ['Draft'] } },
+});
+```
+
+Nothing else to wire: importing this package is what makes `'memory'` an answered name.
+`@fougere/app` already depends on it, so the fallback needs no declaration at all.
+
+## It answers the whole port
+
+The thirteen gestures, not six — and it reads the axes, which is the difference between a
+store and a stand-in. A `primary(text())` with no generator is refused rather than given an
+invented `id`; `created()` is stamped; a second `create` on one key is refused instead of
+overwriting in silence.
+
+That is not written here. `storageOver` (`@fougere/core`) derives the thirteen from the four
+below, so this package is the four:
+
+```ts
+const store = new Map<string, Row>();
+
+return {
+  client: store,
+  get: async (key) => store.get(key),
+  has: async (key) => store.has(key),
+  set: async (key, row) => { store.set(key, row); },
+  delete: async (key) => store.delete(key),
+  all: async () => [...store.values()],
+};
+```
+
+## What it does not declare
+
+No `transacted`: a Map has no unit of work. A
+[frame](https://fougere.dev/docs/business/together) reads the absence, compensates instead of
+transacting, and the boot says which of the two it built. No `migrate` either — a Map has no
+shape to bring up to date.
+
+Rows live for the life of the process and go with it. Nothing is written anywhere; for rows
+that must survive a restart, see `@fougere/adapter-file`.

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Rows in a Map — the source that ships no driver, in the ten lines the frame leaves.
+ *
+ * It is what an app with no `db` runs on, and what a test runs on when the shape is the
+ * subject and the engine is not. `storageOver` derives the thirteen gestures from the four
+ * below, so nothing about pages, criteria or lifecycle stamps is respelled here — three
+ * hand-written copies of this in the demos each answered six of the thirteen, forced the
+ * field name `id` and minted a uuid whatever the entity declared.
+ *
+ * No `transacted`: a Map has no unit of work, so a frame reads the absence and compensates
+ * instead of transacting (`boot/together.ts`), saying which of the two it built. No
+ * `migrate` either — a Map has no shape to bring up to date.
+ */
+import { type Source } from '@fougere/core';
+/** The whole port over a Map, per entity. */
+export declare const createMemoryStorage: import("@fougere/core").StorageFactory;
+export declare function setupMemory(): Source;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAA6C,KAAK,MAAM,EAAqB,MAAM,eAAe,CAAC;AAgB1G,6CAA6C;AAC7C,eAAO,MAAM,mBAAmB,wCAA+B,CAAC;AAEhE,wBAAgB,WAAW,IAAI,MAAM,CAEpC"}

package/dist/index.js

@@ -0,0 +1,33 @@
+/**
+ * Rows in a Map — the source that ships no driver, in the ten lines the frame leaves.
+ *
+ * It is what an app with no `db` runs on, and what a test runs on when the shape is the
+ * subject and the engine is not. `storageOver` derives the thirteen gestures from the four
+ * below, so nothing about pages, criteria or lifecycle stamps is respelled here — three
+ * hand-written copies of this in the demos each answered six of the thirteen, forced the
+ * field name `id` and minted a uuid whatever the entity declared.
+ *
+ * No `transacted`: a Map has no unit of work, so a frame reads the absence and compensates
+ * instead of transacting (`boot/together.ts`), saying which of the two it built. No
+ * `migrate` either — a Map has no shape to bring up to date.
+ */
+import { Sources, storageOver } from '@fougere/core';
+/** One entity's rows. Held for the life of the process, released with nothing to close. */
+function mapRows() {
+    const store = new Map();
+    return {
+        client: store,
+        get: async (key) => store.get(key),
+        has: async (key) => store.has(key),
+        set: async (key, row) => { store.set(key, row); },
+        delete: async (key) => store.delete(key),
+        all: async () => [...store.values()],
+    };
+}
+/** The whole port over a Map, per entity. */
+export const createMemoryStorage = storageOver(() => mapRows());
+export function setupMemory() {
+    return { storageFactory: createMemoryStorage, name: 'memory' };
+}
+Sources.register('memory', (_conf) => setupMemory());
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,OAAO,EAAE,WAAW,EAAuD,MAAM,eAAe,CAAC;AAE1G,2FAA2F;AAC3F,SAAS,OAAO;IACd,MAAM,KAAK,GAAG,IAAI,GAAG,EAAe,CAAC;IAErC,OAAO;QACL,MAAM,EAAE,KAAK;QACb,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC;QAClC,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC;QAClC,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;QACjD,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC;QACxC,GAAG,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;KACrC,CAAC;AACJ,CAAC;AAED,6CAA6C;AAC7C,MAAM,CAAC,MAAM,mBAAmB,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,CAAC,CAAC;AAEhE,MAAM,UAAU,WAAW;IACzB,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;AACjE,CAAC;AAED,OAAO,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAmB,EAAU,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC"}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@fougere/adapter-memory",
+  "version": "0.6.0-alpha.0",
+  "description": "Rows in a Map — the source a first run meets, and the one that ships no driver.",
+  "keywords": [
+    "fougere",
+    "typescript",
+    "storage",
+    "in-memory",
+    "testing"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chok/fougere.git",
+    "directory": "packages/adapter/memory"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "dependencies": {
+    "@fougere/core": "0.6.0-alpha.0",
+    "@fougere/schema": "0.6.0-alpha.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit -p tsconfig.test.json"
+  }
+}

package/src/index.ts

@@ -0,0 +1,37 @@
+/**
+ * Rows in a Map — the source that ships no driver, in the ten lines the frame leaves.
+ *
+ * It is what an app with no `db` runs on, and what a test runs on when the shape is the
+ * subject and the engine is not. `storageOver` derives the thirteen gestures from the four
+ * below, so nothing about pages, criteria or lifecycle stamps is respelled here — three
+ * hand-written copies of this in the demos each answered six of the thirteen, forced the
+ * field name `id` and minted a uuid whatever the entity declared.
+ *
+ * No `transacted`: a Map has no unit of work, so a frame reads the absence and compensates
+ * instead of transacting (`boot/together.ts`), saying which of the two it built. No
+ * `migrate` either — a Map has no shape to bring up to date.
+ */
+import { Sources, storageOver, type Row, type Rows, type Source, type SourceConfig } from '@fougere/core';
+
+/** One entity's rows. Held for the life of the process, released with nothing to close. */
+function mapRows(): Rows {
+  const store = new Map<string, Row>();
+
+  return {
+    client: store,
+    get: async (key) => store.get(key),
+    has: async (key) => store.has(key),
+    set: async (key, row) => { store.set(key, row); },
+    delete: async (key) => store.delete(key),
+    all: async () => [...store.values()],
+  };
+}
+
+/** The whole port over a Map, per entity. */
+export const createMemoryStorage = storageOver(() => mapRows());
+
+export function setupMemory(): Source {
+  return { storageFactory: createMemoryStorage, name: 'memory' };
+}
+
+Sources.register('memory', (_conf: SourceConfig): Source => setupMemory());