@deterministic-code/datasources-json 0.0.0-stage → 0.1.3

package/dist/JsonDriver.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 JsonDriver 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/JsonDriver.js

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

package/dist/command.d.ts

@@ -0,0 +1,14 @@
+import { CommandMiddlewareHost, Native, type Cells, type ICommand, type IReader, type IStatement, Response, type Parameter } from "@deterministic-code/datasources";
+import type { JsonConnection } from "./connection.js";
+export declare class JsonCommand extends CommandMiddlewareHost implements ICommand {
+    readonly connection: JsonConnection;
+    constructor(connection: JsonConnection);
+    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 applyUpdate;
+    private applyDelete;
+}

package/dist/command.js

@@ -0,0 +1,103 @@
+import { ArrayReader, CommandMiddlewareHost, DeleteStatement, DefaultStatementTextRenderer, InsertStatement, SelectInsertedIdStatement, UpdateStatement, Response, } from "@deterministic-code/datasources";
+import { asRecord, matches, parametersToObject, parseFilter, } from "./filter.js";
+export class JsonCommand 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(asRecord(row), filter));
+            const cells = rows.map(asRecord);
+            return { value: new ArrayReader(cells), rows: cells };
+        });
+    }
+    executeReaderStatement = (statement, parameters) => statement instanceof SelectInsertedIdStatement
+        ? this.run(`${statement.table}.${statement.column}`, parameters, async () => {
+            this.connection.ensureOpen();
+            return { value: new ArrayReader([]), rows: [] };
+        })
+        : this.executeReader(filterText(statement), parameters);
+    executeStatement = (statement, parameters) => statement instanceof InsertStatement
+        ? this.execute("insert", parameters)
+        : statement instanceof UpdateStatement
+            ? this.execute("update", withWhere(parameters, statement.where))
+            : statement instanceof DeleteStatement
+                ? this.execute("delete", withWhere(parameters, 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") {
+                this.connection.getCollection().push(obj);
+                await this.connection.persist();
+                return { value: new Response(obj, 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 = await this.applyUpdate(next, filter);
+                return { value: new Response(updated.result, updated.rowsAffected, params), rows: [] };
+            }
+            if (op === "delete") {
+                const filter = obj;
+                const deleted = await this.applyDelete(filter);
+                return { value: new Response(deleted.result, deleted.rowsAffected, params), rows: [] };
+            }
+            throw new Error(`Unsupported JSON command: ${query}`);
+        });
+    }
+    async applyUpdate(obj, filter) {
+        const collection = this.connection.getCollection();
+        let rowsAffected = 0;
+        for (let i = 0; i < collection.length; i += 1) {
+            if (matches(asRecord(collection[i]), filter)) {
+                collection[i] = { ...asRecord(collection[i]), ...obj };
+                rowsAffected += 1;
+            }
+        }
+        await this.connection.persist();
+        return { result: obj, rowsAffected };
+    }
+    async applyDelete(filter) {
+        const collection = this.connection.getCollection();
+        const remaining = collection.filter((row) => !matches(asRecord(row), filter));
+        const rowsAffected = collection.length - remaining.length;
+        collection.length = 0;
+        collection.push(...remaining);
+        await this.connection.persist();
+        return { result: undefined, rowsAffected };
+    }
+}
+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 withWhere = (parameters, where) => looksJson(renderWhere(where))
+    ? [...(parameters ?? []), { name: "$where", value: renderWhere(where) }]
+    : parameters;

package/dist/connection-options.d.ts

@@ -0,0 +1,7 @@
+import type { IFileStore } from "./file-store.js";
+export interface JsonConnectionOptions {
+    path?: string;
+    collection?: string;
+    fileStore?: IFileStore;
+    data?: unknown;
+}

package/dist/connection-options.js

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

package/dist/connection.d.ts

@@ -0,0 +1,28 @@
+import { type DatasourceOptions, type ICommand, type IConnection, type IsolationLevelName, type ITransaction } from "@deterministic-code/datasources";
+import type { JsonConnectionOptions } from "./connection-options.js";
+import { type IFileStore } from "./file-store.js";
+export declare class JsonConnection implements IConnection {
+    readonly provider = "json";
+    path: string;
+    collection?: string;
+    fileStore: IFileStore;
+    data: unknown;
+    isOpen: boolean;
+    inTransaction: boolean;
+    private snapshot;
+    private readonly initialData?;
+    private readonly hasInitialData;
+    static from: (options?: DatasourceOptions) => JsonConnection;
+    constructor(options?: JsonConnectionOptions);
+    createCommand: () => ICommand;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    [Symbol.asyncDispose]: () => Promise<void>;
+    startTransaction(isolation?: IsolationLevelName): Promise<ITransaction>;
+    getCollection(): unknown[];
+    persist(): Promise<void>;
+    finishCommit(): void;
+    finishAbort(): void;
+    ensureOpen(): void;
+    private emptyData;
+}

package/dist/connection.js

@@ -0,0 +1,92 @@
+import { DatasourceError, DatasourceUrlParser, IsolationLevel, } from "@deterministic-code/datasources";
+import { JsonCommand } from "./command.js";
+import { MemoryFileStore } from "./file-store.js";
+import { JsonTransaction } from "./transaction.js";
+export class JsonConnection {
+    provider = "json";
+    path;
+    collection;
+    fileStore;
+    data;
+    isOpen = false;
+    inTransaction = false;
+    snapshot;
+    initialData;
+    hasInitialData;
+    static from = (options) => new JsonConnection({
+        path: DatasourceUrlParser.parse(options?.DATASOURCE_URL)?.datasource ?? "",
+    });
+    constructor(options = {}) {
+        this.path = options.path ?? "";
+        this.collection = options.collection;
+        this.fileStore = options.fileStore ?? new MemoryFileStore();
+        this.hasInitialData = Object.prototype.hasOwnProperty.call(options, "data");
+        this.initialData = options.data;
+        this.data = this.emptyData();
+    }
+    createCommand = () => new JsonCommand(this);
+    async open() {
+        if (this.isOpen)
+            throw new DatasourceError("Connection is already open");
+        if (this.hasInitialData) {
+            this.data = structuredClone(this.initialData);
+        }
+        else if (this.path && (await this.fileStore.exists(this.path))) {
+            const contents = await this.fileStore.read(this.path);
+            this.data = JSON.parse(contents);
+        }
+        else {
+            this.data = this.emptyData();
+        }
+        if (this.collection) {
+            this.getCollection();
+        }
+        this.isOpen = true;
+    }
+    async close() {
+        this.isOpen = false;
+    }
+    [Symbol.asyncDispose] = () => this.close();
+    async startTransaction(isolation = IsolationLevel.Serializable) {
+        this.ensureOpen();
+        this.snapshot = structuredClone(this.data);
+        this.inTransaction = true;
+        return new JsonTransaction(this, isolation);
+    }
+    getCollection() {
+        if (this.collection) {
+            if (this.data === null || typeof this.data !== "object" || Array.isArray(this.data)) {
+                this.data = {};
+            }
+            const root = this.data;
+            if (!Array.isArray(root[this.collection])) {
+                root[this.collection] = [];
+            }
+            return root[this.collection];
+        }
+        if (!Array.isArray(this.data)) {
+            this.data = [];
+        }
+        return this.data;
+    }
+    async persist() {
+        if (this.inTransaction || !this.path) {
+            return;
+        }
+        await this.fileStore.write(this.path, JSON.stringify(this.data));
+    }
+    finishCommit() {
+        this.inTransaction = false;
+        this.snapshot = undefined;
+    }
+    finishAbort() {
+        this.data = this.snapshot;
+        this.inTransaction = false;
+        this.snapshot = undefined;
+    }
+    ensureOpen() {
+        if (!this.isOpen)
+            throw new DatasourceError("Connection is not open");
+    }
+    emptyData = () => (this.collection ? {} : []);
+}

package/dist/file-store.d.ts

@@ -0,0 +1,3 @@
+export type { FileSystemApi, IFileStore } from "./i-file-store.js";
+export { MemoryFileStore } from "./memory-file-store.js";
+export { NodeFileStore } from "./node-file-store.js";

package/dist/file-store.js

@@ -0,0 +1,2 @@
+export { MemoryFileStore } from "./memory-file-store.js";
+export { NodeFileStore } from "./node-file-store.js";

package/dist/filter.d.ts

@@ -0,0 +1,7 @@
+export declare function parseFilter(text?: string | null): Record<string, unknown>;
+export declare function matches(obj: Record<string, unknown>, filter: Record<string, unknown>): boolean;
+export declare function asRecord(obj: unknown): Record<string, unknown>;
+export declare function parametersToObject(parameters?: {
+    name: string;
+    value: unknown;
+}[]): Record<string, unknown>;

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("JSON 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/i-file-store.d.ts

@@ -0,0 +1,10 @@
+export interface IFileStore {
+    read(path: string): Promise<string>;
+    write(path: string, contents: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+}
+export interface FileSystemApi {
+    readFile(path: string, encoding: "utf8"): Promise<string>;
+    writeFile(path: string, contents: string, encoding: "utf8"): Promise<void>;
+    access(path: string): Promise<void>;
+}

package/dist/i-file-store.js

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

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/memory-file-store.d.ts

@@ -0,0 +1,8 @@
+import type { IFileStore } from "./i-file-store.js";
+export declare class MemoryFileStore implements IFileStore {
+    files: Map<string, string>;
+    constructor(files?: Map<string, string>);
+    read(path: string): Promise<string>;
+    write(path: string, contents: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+}

package/dist/memory-file-store.js

@@ -0,0 +1,18 @@
+export class MemoryFileStore {
+    files;
+    constructor(files = new Map()) {
+        this.files = files;
+    }
+    async read(path) {
+        const contents = this.files.get(path);
+        if (contents === undefined)
+            throw new Error(`File not found: ${path}`);
+        return contents;
+    }
+    async write(path, contents) {
+        this.files.set(path, contents);
+    }
+    async exists(path) {
+        return this.files.has(path);
+    }
+}

package/dist/node-file-store.d.ts

@@ -0,0 +1,8 @@
+import type { FileSystemApi, IFileStore } from "./i-file-store.js";
+export declare class NodeFileStore implements IFileStore {
+    private readonly fs;
+    constructor(fs?: FileSystemApi);
+    read(path: string): Promise<string>;
+    write(path: string, contents: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+}

package/dist/node-file-store.js

@@ -0,0 +1,27 @@
+import * as nodeFs from "node:fs/promises";
+const defaultFs = {
+    readFile: (path, encoding) => nodeFs.readFile(path, encoding),
+    writeFile: (path, contents, encoding) => nodeFs.writeFile(path, contents, encoding),
+    access: (path) => nodeFs.access(path),
+};
+export class NodeFileStore {
+    fs;
+    constructor(fs = defaultFs) {
+        this.fs = fs;
+    }
+    async read(path) {
+        return this.fs.readFile(path, "utf8");
+    }
+    async write(path, contents) {
+        await this.fs.writeFile(path, contents, "utf8");
+    }
+    async exists(path) {
+        try {
+            await this.fs.access(path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/transaction.d.ts

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

package/dist/transaction.js

@@ -0,0 +1,18 @@
+import { IsolationLevel, } from "@deterministic-code/datasources";
+export class JsonTransaction {
+    connection;
+    isolation;
+    constructor(connection, isolation = IsolationLevel.ReadCommitted) {
+        this.connection = connection;
+        this.isolation = isolation;
+    }
+    async commit() {
+        this.connection.finishCommit();
+        if (this.connection.path) {
+            await this.connection.fileStore.write(this.connection.path, JSON.stringify(this.connection.data));
+        }
+    }
+    async abort() {
+        this.connection.finishAbort();
+    }
+}

package/package.json

@@ -1,6 +1,23 @@
 {
   "name": "@deterministic-code/datasources-json",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.3",
+  "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.3"
+  }
+}

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.