@deterministic-code/datasources-memory 0.0.0-stage → 0.1.2

package/dist/MemoryDriver.d.ts

@@ -0,0 +1,8 @@
+import { type Cell, type DatasourceOptions, type ICommand, type IConnection, type IDriver, type ITransaction, type IsolationLevel, type TypeConverter } from "@deterministic-code/datasources";
+export declare class MemoryDriver implements IDriver {
+    rowTypeConverters: Record<string, TypeConverter<Cell, Cell>>;
+    columnType: (name: string) => string;
+    connection: (options?: DatasourceOptions) => IConnection;
+    command: (connection: IConnection) => ICommand;
+    transaction: (connection: IConnection, isolation?: IsolationLevel) => ITransaction;
+}

package/dist/MemoryDriver.js

@@ -0,0 +1,10 @@
+import { columnType as identityColumnType, } from "@deterministic-code/datasources";
+import { MemoryConnection } from "./connection.js";
+import { MemoryTransaction } from "./transaction.js";
+export class MemoryDriver {
+    rowTypeConverters = {};
+    columnType = identityColumnType;
+    connection = (options) => MemoryConnection.from(options);
+    command = (connection) => connection.createCommand();
+    transaction = (connection, isolation = "readCommitted") => new MemoryTransaction(connection, isolation);
+}

package/dist/command.d.ts

@@ -0,0 +1,17 @@
+import { CommandMiddlewareHost, Native, type Cells, type ICommand, type IReader, type IStatement, Response, type Parameter } from "@deterministic-code/datasources";
+import type { MemoryConnection } from "./connection.js";
+export declare class MemoryCommand extends CommandMiddlewareHost implements ICommand {
+    readonly connection: MemoryConnection;
+    constructor(connection: MemoryConnection);
+    executeReaderNative(text: Native, parameters?: Parameter[]): Promise<IReader<Cells>>;
+    executeNative(text: Native, parameters?: Parameter[]): Promise<Response>;
+    executeReader(text: string, parameters?: Parameter[]): Promise<IReader<Cells>>;
+    executeReaderStatement: (statement: IStatement, parameters?: Parameter[]) => Promise<IReader<Cells>>;
+    executeStatement: (statement: IStatement, parameters?: Parameter[]) => Promise<Response>;
+    execute(text: string, parameters?: Parameter[]): Promise<Response>;
+    private write;
+    private applyChanged;
+    private removeMatched;
+    private applyUpdate;
+    private applyDelete;
+}

package/dist/command.js

@@ -0,0 +1,207 @@
+import { ArrayReader, CommandMiddlewareHost, DeleteStatement, DefaultStatementTextRenderer, InsertStatement, SelectInsertedIdStatement, ExpressionEvaluator, UpdateStatement, Where, Response, } from "@deterministic-code/datasources";
+import { matches, parametersToObject, parseFilter } from "./filter.js";
+export class MemoryCommand extends CommandMiddlewareHost {
+    connection;
+    constructor(connection) {
+        super();
+        this.connection = connection;
+    }
+    executeReaderNative(text, parameters) {
+        return this.executeReader(text.text, parameters);
+    }
+    executeNative(text, parameters) {
+        return this.execute(text.text, parameters);
+    }
+    async executeReader(text, parameters) {
+        return this.run(text, parameters, async (query, params) => {
+            this.connection.ensureOpen();
+            const filter = {
+                ...parseFilter(query),
+                ...parametersToObject(params),
+            };
+            const rows = this.connection
+                .getCollection()
+                .filter((row) => matches(row, filter));
+            return { value: new ArrayReader(rows), rows: rows };
+        });
+    }
+    executeReaderStatement = (statement, parameters) => {
+        if (statement instanceof SelectInsertedIdStatement) {
+            return this.run(`${statement.table}.${statement.column}`, parameters, async () => {
+                this.connection.ensureOpen();
+                const id = this.connection.insertedId(statement.table);
+                const rows = id === undefined ? [] : [{ [statement.column]: id }];
+                return { value: new ArrayReader(rows), rows };
+            });
+        }
+        const clause = "where" in statement && statement.where instanceof Where ? statement.where : undefined;
+        if (clause) {
+            return this.run(DefaultStatementTextRenderer.instance.render(statement), parameters, async () => {
+                this.connection.ensureOpen();
+                const evaluator = new ExpressionEvaluator();
+                const rows = this.connection
+                    .rows(tableOf(statement), false)
+                    .filter((row) => evaluator.evaluate(clause, row) === true);
+                return { value: new ArrayReader(rows), rows: rows };
+            });
+        }
+        if ("where" in statement &&
+            !looksJson(renderWhere(statement.where)) &&
+            !looksJson(DefaultStatementTextRenderer.instance.render(statement))) {
+            return this.run(DefaultStatementTextRenderer.instance.render(statement), parameters, async () => {
+                this.connection.ensureOpen();
+                const rows = this.connection.rows(tableOf(statement), false);
+                return { value: new ArrayReader(rows), rows: rows };
+            });
+        }
+        return this.executeReader(filterText(statement), parameters);
+    };
+    executeStatement = (statement, parameters) => statement instanceof InsertStatement
+        ? this.write("insert", parameters, tableOf(statement), true)
+        : statement instanceof UpdateStatement
+            ? this.write("update", parameters, tableOf(statement), false, statement.where)
+            : statement instanceof DeleteStatement
+                ? this.write("delete", parameters, tableOf(statement), false, statement.where)
+                : this.execute(DefaultStatementTextRenderer.instance.render(statement), parameters);
+    async execute(text, parameters) {
+        if (!text.trim())
+            throw new Error("empty command");
+        return this.run(text, parameters, async (query, params) => {
+            this.connection.ensureOpen();
+            const op = query.trim().toLowerCase();
+            const obj = parametersToObject(params);
+            if (op === "insert") {
+                const row = { ...obj };
+                const id = insertedId(row, this.connection.getCollection());
+                row.id = id;
+                this.connection.getCollection().push(row);
+                this.connection.rememberInserted(this.connection.collection, id);
+                return { value: new Response(id, 1, params), rows: [] };
+            }
+            if (op === "update") {
+                const whereText = typeof obj.$where === "string" ? obj.$where : undefined;
+                const next = { ...obj };
+                delete next.$where;
+                const filter = whereText ? parseFilter(whereText) : next;
+                const updated = this.applyUpdate(this.connection.getCollection(), next, filter);
+                return { value: new Response(updated.result, updated.rowsAffected, params), rows: [] };
+            }
+            if (op === "delete") {
+                const filter = obj;
+                const deleted = this.applyDelete(this.connection.getCollection(), filter);
+                return { value: new Response(deleted.result, deleted.rowsAffected, params), rows: [] };
+            }
+            throw new Error(`Unsupported Memory command: ${query}`);
+        });
+    }
+    write = (op, parameters, table, create, where) => this.run(op, parameters, async (_query, params) => {
+        this.connection.ensureOpen();
+        const rows = this.connection.rows(table, create);
+        const obj = parametersToObject(params);
+        if (op === "insert") {
+            const row = { ...obj };
+            const id = insertedId(row, rows);
+            row.id = id;
+            rows.push(row);
+            this.connection.rememberInserted(table ?? this.connection.collection, id);
+            return { value: new Response(id, 1, params), rows: [] };
+        }
+        if (op === "update") {
+            const updated = this.applyChanged(rows, obj, where, params);
+            return { value: new Response(updated.result, updated.rowsAffected, params), rows: [] };
+        }
+        const deleted = this.removeMatched(rows, obj, where);
+        return { value: new Response(deleted.result, deleted.rowsAffected, params), rows: [] };
+    });
+    applyChanged = (rows, obj, where, parameters) => {
+        if (where instanceof Where) {
+            const evaluator = new ExpressionEvaluator();
+            const names = setNames(parameters, where);
+            let rowsAffected = 0;
+            for (const row of rows) {
+                if (evaluator.evaluate(where, row) !== true)
+                    continue;
+                for (const name of names)
+                    if (name in obj)
+                        row[name] = obj[name];
+                rowsAffected += 1;
+            }
+            return { result: undefined, rowsAffected };
+        }
+        const next = { ...obj };
+        delete next.$where;
+        const filter = looksJson(renderWhere(where)) ? parseFilter(renderWhere(where)) : next;
+        return this.applyUpdate(rows, next, filter);
+    };
+    removeMatched = (rows, obj, where) => {
+        if (where instanceof Where) {
+            const evaluator = new ExpressionEvaluator();
+            const remaining = rows.filter((row) => evaluator.evaluate(where, row) !== true);
+            const rowsAffected = rows.length - remaining.length;
+            rows.length = 0;
+            rows.push(...remaining);
+            return { result: undefined, rowsAffected };
+        }
+        const filter = looksJson(renderWhere(where)) ? parseFilter(renderWhere(where)) : obj;
+        return this.applyDelete(rows, filter);
+    };
+    applyUpdate(collection, obj, filter) {
+        let rowsAffected = 0;
+        for (let i = 0; i < collection.length; i += 1) {
+            if (matches(collection[i], filter)) {
+                collection[i] = { ...collection[i], ...obj };
+                rowsAffected += 1;
+            }
+        }
+        return { result: obj, rowsAffected };
+    }
+    applyDelete(collection, filter) {
+        const remaining = collection.filter((row) => !matches(row, filter));
+        const rowsAffected = collection.length - remaining.length;
+        collection.length = 0;
+        collection.push(...remaining);
+        return { result: undefined, rowsAffected };
+    }
+}
+const insertedId = (row, rows) => typeof row.id === "number"
+    ? row.id
+    : rows.reduce((max, item) => (typeof item.id === "number" && item.id > max ? item.id : max), 0) + 1;
+const looksJson = (text) => !!text?.trimStart().startsWith("{");
+const renderWhere = (where) => where ? DefaultStatementTextRenderer.instance.render(where) : undefined;
+const filterText = (statement) => {
+    const where = "where" in statement ? renderWhere(statement.where) : undefined;
+    if (looksJson(where))
+        return where;
+    const text = DefaultStatementTextRenderer.instance.render(statement);
+    return looksJson(text) || !text.trim() ? text : "";
+};
+const tableOf = (statement) => {
+    if ("table" in statement && typeof statement.table === "string" && statement.table.length > 0)
+        return statement.table;
+    return tableIn(DefaultStatementTextRenderer.instance.render(statement));
+};
+const tableIn = (text) => {
+    const sql = text.trimStart();
+    const lower = sql.toLowerCase();
+    const skip = lower.startsWith("insert into ")
+        ? "insert into ".length
+        : lower.startsWith("delete from ")
+            ? "delete from ".length
+            : lower.startsWith("update ")
+                ? "update ".length
+                : lower.indexOf(" from ") >= 0
+                    ? lower.indexOf(" from ") + " from ".length
+                    : -1;
+    if (skip < 0 || skip >= sql.length)
+        return undefined;
+    const rest = sql.slice(skip);
+    const end = rest.search(/[\s(]/);
+    const name = end < 0 ? rest : rest.slice(0, end);
+    return name.length > 0 ? name : undefined;
+};
+const setNames = (parameters, where) => {
+    const bound = new Set((where.parameters ?? []).map((parameter) => parameter.name));
+    return (parameters ?? [])
+        .map((parameter) => parameter.name)
+        .filter((name) => !bound.has(name) && !name.endsWith("__where"));
+};

package/dist/connection-options.d.ts

@@ -0,0 +1,6 @@
+import type { MemoryRecord, MemoryStore } from "./store.js";
+export interface MemoryConnectionOptions {
+    collection?: string;
+    store?: MemoryStore;
+    data?: MemoryRecord[] | Record<string, MemoryRecord[]>;
+}

package/dist/connection-options.js

@@ -0,0 +1 @@
+export {};

package/dist/connection.d.ts

@@ -0,0 +1,27 @@
+import { type DatasourceOptions, type ICommand, type IConnection, type IsolationLevelName, type ITransaction, type Scalar } from "@deterministic-code/datasources";
+import type { MemoryConnectionOptions } from "./connection-options.js";
+import { MemoryStore, type MemoryRecord } from "./store.js";
+export declare class MemoryConnection implements IConnection {
+    readonly provider = "memory";
+    store: MemoryStore;
+    collection: string;
+    isOpen: boolean;
+    inTransaction: boolean;
+    private snapshot?;
+    private readonly inserted;
+    private readonly data?;
+    static from: (_options?: DatasourceOptions) => MemoryConnection;
+    constructor(options?: MemoryConnectionOptions);
+    createCommand: () => ICommand;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    [Symbol.asyncDispose]: () => Promise<void>;
+    startTransaction(isolation?: IsolationLevelName): Promise<ITransaction>;
+    getCollection(): MemoryRecord[];
+    rememberInserted(table: string, id: Scalar): void;
+    insertedId(table: string): Scalar | undefined;
+    rows(table: string | undefined, create: boolean): MemoryRecord[];
+    finishCommit(): void;
+    finishAbort(): void;
+    ensureOpen(): void;
+}

package/dist/connection.js

@@ -0,0 +1,69 @@
+import { DatasourceError, IsolationLevel, } from "@deterministic-code/datasources";
+import { MemoryCommand } from "./command.js";
+import { MemoryStore } from "./store.js";
+import { MemoryTransaction } from "./transaction.js";
+export class MemoryConnection {
+    provider = "memory";
+    store;
+    collection;
+    isOpen = false;
+    inTransaction = false;
+    snapshot;
+    inserted = new Map();
+    data;
+    static from = (_options) => new MemoryConnection();
+    constructor(options = {}) {
+        this.store = options.store ?? new MemoryStore();
+        this.collection = options.collection ?? "";
+        this.data = options.data;
+    }
+    createCommand = () => new MemoryCommand(this);
+    async open() {
+        if (this.isOpen)
+            throw new DatasourceError("Connection is already open");
+        if (this.data !== undefined) {
+            this.store.seed(this.data, this.collection);
+        }
+        this.store.getCollection(this.collection);
+        this.isOpen = true;
+    }
+    async close() {
+        this.isOpen = false;
+    }
+    [Symbol.asyncDispose] = () => this.close();
+    async startTransaction(isolation = IsolationLevel.Serializable) {
+        this.ensureOpen();
+        this.snapshot = this.store.snapshot();
+        this.inTransaction = true;
+        return new MemoryTransaction(this, isolation);
+    }
+    getCollection() {
+        return this.store.getCollection(this.collection);
+    }
+    rememberInserted(table, id) {
+        this.inserted.set(table, id);
+    }
+    insertedId(table) {
+        return this.inserted.get(table);
+    }
+    rows(table, create) {
+        return table && (create || this.store.hasCollection(table))
+            ? this.store.getCollection(table)
+            : this.getCollection();
+    }
+    finishCommit() {
+        this.inTransaction = false;
+        this.snapshot = undefined;
+    }
+    finishAbort() {
+        if (this.snapshot) {
+            this.store.restore(this.snapshot);
+        }
+        this.inTransaction = false;
+        this.snapshot = undefined;
+    }
+    ensureOpen() {
+        if (!this.isOpen)
+            throw new DatasourceError("Connection is not open");
+    }
+}

package/dist/filter.d.ts

@@ -0,0 +1,8 @@
+import type { MemoryRecord } from "./store.js";
+export declare function parseFilter(text?: string | null): MemoryRecord;
+export declare function matches(obj: MemoryRecord, filter: MemoryRecord): boolean;
+export declare function asRecord(obj: unknown): MemoryRecord;
+export declare function parametersToObject(parameters?: {
+    name: string;
+    value: unknown;
+}[]): MemoryRecord;

package/dist/filter.js

@@ -0,0 +1,29 @@
+export function parseFilter(text) {
+    if (text === undefined || text === null || text.trim() === "") {
+        return {};
+    }
+    const parsed = JSON.parse(text);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("Memory filter must be an object");
+    }
+    return parsed;
+}
+export function matches(obj, filter) {
+    return Object.entries(filter).every(([key, value]) => obj[key] === value);
+}
+export function asRecord(obj) {
+    if (obj === null || typeof obj !== "object" || Array.isArray(obj)) {
+        throw new Error("Repository objects must be plain objects");
+    }
+    return obj;
+}
+export function parametersToObject(parameters) {
+    const record = {};
+    if (!parameters) {
+        return record;
+    }
+    for (const parameter of parameters) {
+        record[parameter.name] = parameter.value;
+    }
+    return record;
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { MemoryDriver } from "./MemoryDriver.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { MemoryDriver } from "./MemoryDriver.js";

package/dist/store.d.ts

@@ -0,0 +1,9 @@
+export type MemoryRecord = Record<string, unknown>;
+export declare class MemoryStore {
+    readonly collections: Map<string, MemoryRecord[]>;
+    hasCollection(name: string): boolean;
+    getCollection(name: string): MemoryRecord[];
+    snapshot(): Map<string, MemoryRecord[]>;
+    restore(snapshot: Map<string, MemoryRecord[]>): void;
+    seed(data: MemoryRecord[] | Record<string, MemoryRecord[]>, collection: string): void;
+}

package/dist/store.js

@@ -0,0 +1,39 @@
+export class MemoryStore {
+    collections = new Map();
+    hasCollection(name) {
+        return this.collections.has(name);
+    }
+    getCollection(name) {
+        let rows = this.collections.get(name);
+        if (!rows) {
+            rows = [];
+            this.collections.set(name, rows);
+        }
+        return rows;
+    }
+    snapshot() {
+        return new Map([...this.collections].map(([name, rows]) => [
+            name,
+            rows.map((row) => ({ ...row })),
+        ]));
+    }
+    restore(snapshot) {
+        this.collections.clear();
+        for (const [name, rows] of snapshot) {
+            this.collections.set(name, rows.map((row) => ({ ...row })));
+        }
+    }
+    seed(data, collection) {
+        if (Array.isArray(data)) {
+            if (!this.hasCollection(collection)) {
+                this.collections.set(collection, data.map((row) => ({ ...row })));
+            }
+            return;
+        }
+        for (const [name, rows] of Object.entries(data)) {
+            if (!this.hasCollection(name)) {
+                this.collections.set(name, rows.map((row) => ({ ...row })));
+            }
+        }
+    }
+}

package/dist/transaction.d.ts

@@ -0,0 +1,9 @@
+import { type ITransaction, type IsolationLevelName } from "@deterministic-code/datasources";
+import type { MemoryConnection } from "./connection.js";
+export declare class MemoryTransaction implements ITransaction {
+    readonly connection: MemoryConnection;
+    readonly isolation: IsolationLevelName;
+    constructor(connection: MemoryConnection, isolation?: IsolationLevelName);
+    commit(): Promise<void>;
+    abort(): Promise<void>;
+}

package/dist/transaction.js

@@ -0,0 +1,15 @@
+import { IsolationLevel, } from "@deterministic-code/datasources";
+export class MemoryTransaction {
+    connection;
+    isolation;
+    constructor(connection, isolation = IsolationLevel.ReadCommitted) {
+        this.connection = connection;
+        this.isolation = isolation;
+    }
+    async commit() {
+        this.connection.finishCommit();
+    }
+    async abort() {
+        this.connection.finishAbort();
+    }
+}

package/package.json

@@ -1,6 +1,23 @@
 {
   "name": "@deterministic-code/datasources-memory",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.2",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.js",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@deterministic-code/datasources": "^0.1.2"
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-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.