@wxn0brp/db-core 0.0.1

package/.github/workflows/build-relase.yml

@@ -0,0 +1,25 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - '*'
+  workflow_dispatch:
+
+concurrency:
+  group: build-release
+  cancel-in-progress: true
+
+jobs:
+  build:
+    uses: wxn0brP/workflow-dist/.github/workflows/build-ts.yml@main
+    with:
+      files: "dist package.json README.md LICENSE"
+      publishToNpm: true
+      scriptsHandling: "remove-all"
+      customCommands: |
+        v=$(jq -r .version package.json)
+        echo "export const version = \"$v\";" > dist/version.js
+        
+    secrets:
+      NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

package/.github/workflows/build.yml

@@ -0,0 +1,20 @@
+name: Nightly
+
+on:
+  push:
+    branches:
+      - master
+  workflow_dispatch:
+
+concurrency:
+  group: build-master
+  cancel-in-progress: true
+
+jobs:
+  build:
+    uses: wxn0brP/workflow-dist/.github/workflows/build-ts.yml@main
+    with:
+      scriptsHandling: 'remove-all'
+      customCommands: |
+        v=$(jq -r .version package.json)
+        echo "export const version = \"$v\";" > dist/version.js

package/.github/workflows/types.yml

@@ -0,0 +1,89 @@
+name: Types
+
+on:
+  push:
+    branches:
+      - master
+    tags:
+      - '*'
+
+  pull_request:
+    branches:
+      - master
+  workflow_dispatch:
+
+concurrency:
+  group: build-types
+  cancel-in-progress: true
+
+jobs:
+  deploy-types:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+
+    steps:
+      - name: Checkout Repo
+        uses: actions/checkout@v3
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: 22
+
+      - name: Install Dependencies
+        run: |
+          npm i
+          npm install -g tsc-alias
+
+      - name: Build Declarations Only
+        run: |
+          npx tsc --emitDeclarationOnly --declaration --removeComments --outDir dist --project tsconfig.json
+          tsc-alias
+
+      - name: Prepare Clean package.json
+        run: |
+          jq 'del(
+            .scripts,
+            .dependencies,
+            .devDependencies,
+            .peerDependencies,
+            .optionalDependencies,
+            .bundledDependencies
+          )' package.json > dist/package.json
+          rm package.json
+          mv dist/package.json package.json
+
+      - name: Push to `types` Branch
+        run: |
+          git config --global user.name "github-actions[bot]"
+          git config --global user.email "github-actions[bot]@users.noreply.github.com"
+
+          git checkout --orphan types
+          git reset -q HEAD --
+
+          git add -f -A dist LICENSE package.json
+          git commit -m "Deploy type definitions only"
+          git push origin types --force
+
+      - name: Push to `types-only` Branch
+        run: |
+          git config --global user.name "github-actions[bot]"
+          git config --global user.email "github-actions[bot]@users.noreply.github.com"
+
+          git checkout --orphan types-only
+          git reset -q HEAD --
+
+          cat << EOF > dist/index.d.ts
+          import { ValtheraTypes } from "./types/export";
+          import { RelationTypes } from "./types/relation";
+          import { ValtheraCompatible } from "./types/valthera";
+          export type { RelationTypes, ValtheraCompatible, ValtheraTypes };
+          export type Id = import("./types/Id").Id;
+          EOF
+
+          echo "export {}" > dist/index.js
+
+          git add -f -A dist/types dist/index.d.ts dist/index.js LICENSE package.json
+          git commit -m "Deploy type definitions only"
+          git push origin types-only --force

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+
+All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
+
+### 0.0.1 (2025-07-12)
+
+### [0.0.1](https://github.com/wxn0brP/ValtheraDB-core/compare/v0.0.2...v0.0.1) (2025-07-12)
+
+### 0.0.2 (2025-07-12)

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 wxn0brP
+
+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,5 @@
+# ValtheraDB Core
+
+This is the core library for [ValtheraDB](https://github.com/wxn0brp/ValtheraDB)
+
+It is `not recommended` to install this module separately unless you plan to create your own ValtheraDB adapter

package/dist/base/actions.d.ts

@@ -0,0 +1,17 @@
+import Data from "../types/data.js";
+import { VQuery } from "../types/query.js";
+declare class dbActionBase {
+    getCollections(): Promise<string[]>;
+    checkCollection(config: VQuery): Promise<boolean>;
+    issetCollection(config: VQuery): Promise<boolean>;
+    add(config: VQuery): Promise<Data>;
+    find(config: VQuery): Promise<Data[]>;
+    findOne(config: VQuery): Promise<Data | null>;
+    update(config: VQuery): Promise<boolean>;
+    updateOne(config: VQuery): Promise<boolean>;
+    remove(config: VQuery): Promise<boolean>;
+    removeOne(config: VQuery): Promise<boolean>;
+    removeCollection(config: VQuery): Promise<boolean>;
+    updateOneOrAdd(config: VQuery): Promise<boolean>;
+}
+export default dbActionBase;

package/dist/base/actions.js

@@ -0,0 +1,56 @@
+import { setDataUsingUpdateOneOrAdd } from "../helpers/updateOneOrAdd.js";
+class dbActionBase {
+    async getCollections() {
+        throw new Error("Not implemented");
+        return [];
+    }
+    async checkCollection(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+    async issetCollection(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+    async add(config) {
+        throw new Error("Not implemented");
+        return {};
+    }
+    async find(config) {
+        throw new Error("Not implemented");
+        return [];
+    }
+    async findOne(config) {
+        throw new Error("Not implemented");
+        return {};
+    }
+    async update(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+    async updateOne(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+    async remove(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+    async removeOne(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+    async removeCollection(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+    async updateOneOrAdd(config) {
+        const res = await this.updateOne(config);
+        if (!res) {
+            setDataUsingUpdateOneOrAdd(config);
+            await this.add(config);
+        }
+        return res;
+    }
+}
+export default dbActionBase;

package/dist/base/db.d.ts

@@ -0,0 +1,21 @@
+import CollectionManager from "../helpers/CollectionManager.js";
+import Data from "../types/data.js";
+import { VQuery } from "../types/query.js";
+import { ValtheraCompatibleInternal } from "../types/valthera.js";
+declare class ValtheraBase implements ValtheraCompatibleInternal {
+    version: string;
+    c(config: VQuery): CollectionManager;
+    getCollections(): Promise<any[]>;
+    checkCollection(config: VQuery): Promise<boolean>;
+    issetCollection(config: VQuery): Promise<boolean>;
+    add<T = Data>(config: VQuery): Promise<T>;
+    find<T = Data>(config: VQuery): Promise<T[]>;
+    findOne<T = Data>(config: VQuery): Promise<T>;
+    remove(config: VQuery): Promise<boolean>;
+    removeCollection(config: VQuery): Promise<boolean>;
+    removeOne(config: VQuery): Promise<boolean>;
+    update(config: VQuery): Promise<boolean>;
+    updateOne(config: VQuery): Promise<boolean>;
+    updateOneOrAdd(config: VQuery): Promise<boolean>;
+}
+export default ValtheraBase;

package/dist/base/db.js

@@ -0,0 +1,56 @@
+import { version } from "../version.js";
+class ValtheraBase {
+    version = version;
+    c(config) {
+        throw new Error("Not implemented");
+    }
+    async getCollections() {
+        throw new Error("Not implemented");
+        return [];
+    }
+    async checkCollection(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+    async issetCollection(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+    async add(config) {
+        throw new Error("Not implemented");
+        return {};
+    }
+    async find(config) {
+        throw new Error("Not implemented");
+        return [];
+    }
+    async findOne(config) {
+        throw new Error("Not implemented");
+        return {};
+    }
+    async remove(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+    async removeCollection(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+    async removeOne(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+    async update(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+    async updateOne(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+    async updateOneOrAdd(config) {
+        throw new Error("Not implemented");
+        return false;
+    }
+}
+export default ValtheraBase;

package/dist/customFileCpu.d.ts

@@ -0,0 +1,19 @@
+import { Search, Updater } from "./types/arg.js";
+import Data from "./types/data.js";
+import FileCpu from "./types/fileCpu.js";
+import { FindOpts } from "./types/options.js";
+import { VContext } from "./types/types.js";
+export type WriteFile = (file: string, data: any[]) => Promise<void>;
+export type ReadFile = (file: string) => Promise<any[]>;
+export declare function pathRepair(path: string): string;
+declare class CustomFileCpu implements FileCpu {
+    _readFile: ReadFile;
+    _writeFile: WriteFile;
+    constructor(readFile: ReadFile, writeFile: WriteFile);
+    add(file: string, data: Data): Promise<void>;
+    find(file: string, arg: Search, context?: VContext, findOpts?: FindOpts): Promise<any[] | false>;
+    findOne(file: string, arg: Search, context?: VContext, findOpts?: FindOpts): Promise<any | false>;
+    remove(file: string, one: boolean, arg: Search, context?: VContext): Promise<boolean>;
+    update(file: string, one: boolean, arg: Search, updater: Updater, context?: VContext): Promise<boolean>;
+}
+export default CustomFileCpu;

package/dist/customFileCpu.js

@@ -0,0 +1,70 @@
+import hasFieldsAdvanced from "./utils/hasFieldsAdvanced.js";
+import updateFindObject from "./utils/updateFindObject.js";
+export function pathRepair(path) {
+    return path.replaceAll("//", "/");
+}
+class CustomFileCpu {
+    _readFile;
+    _writeFile;
+    constructor(readFile, writeFile) {
+        this._readFile = readFile;
+        this._writeFile = writeFile;
+    }
+    async add(file, data) {
+        file = pathRepair(file);
+        let entries = await this._readFile(file);
+        entries.push(data);
+        await this._writeFile(file, entries);
+    }
+    async find(file, arg, context = {}, findOpts = {}) {
+        file = pathRepair(file);
+        const entries = await this._readFile(file);
+        const results = entries.filter(entry => typeof arg === "function" ? arg(entry, context) : hasFieldsAdvanced(entry, arg));
+        return results.length ? results.map(res => updateFindObject(res, findOpts)) : [];
+    }
+    async findOne(file, arg, context = {}, findOpts = {}) {
+        file = pathRepair(file);
+        const entries = await this._readFile(file);
+        const result = entries.find(entry => typeof arg === "function" ? arg(entry, context) : hasFieldsAdvanced(entry, arg));
+        return result ? updateFindObject(result, findOpts) : false;
+    }
+    async remove(file, one, arg, context = {}) {
+        file = pathRepair(file);
+        let entries = await this._readFile(file);
+        let removed = false;
+        entries = entries.filter(entry => {
+            if (removed && one)
+                return true;
+            let match = typeof arg === "function" ? arg(entry, context) : hasFieldsAdvanced(entry, arg);
+            if (match) {
+                removed = true;
+                return false;
+            }
+            return true;
+        });
+        if (!removed)
+            return false;
+        await this._writeFile(file, entries);
+        return true;
+    }
+    async update(file, one, arg, updater, context = {}) {
+        file = pathRepair(file);
+        let entries = await this._readFile(file);
+        let updated = false;
+        entries = entries.map(entry => {
+            if (updated && one)
+                return entry;
+            let match = typeof arg === "function" ? arg(entry, context) : hasFieldsAdvanced(entry, arg);
+            if (match) {
+                updated = true;
+                return typeof updater === "function" ? updater(entry, context) : { ...entry, ...updater };
+            }
+            return entry;
+        });
+        if (!updated)
+            return false;
+        await this._writeFile(file, entries);
+        return true;
+    }
+}
+export default CustomFileCpu;

package/dist/db/memory.d.ts

@@ -0,0 +1,72 @@
+import ValtheraClass from "./valthera.js";
+import dbActionBase from "../base/actions.js";
+import Data from "../types/data.js";
+import FileCpu from "../types/fileCpu.js";
+import { DbOpts } from "../types/options.js";
+import { VQuery } from "../types/query.js";
+export declare class MemoryAction extends dbActionBase {
+    folder: string;
+    options: DbOpts;
+    fileCpu: FileCpu;
+    memory: Map<string, any[]>;
+    /**
+     * Creates a new instance of dbActionC.
+     * @constructor
+     * @param folder - The folder where database files are stored.
+     * @param options - The options object.
+     */
+    constructor();
+    _readMemory(key: string): any[];
+    _writeMemory(key: string, data: any[]): void;
+    _getCollectionPath(collection: string): string;
+    /**
+     * Get a list of available databases in the specified folder.
+     */
+    getCollections(): Promise<string[]>;
+    /**
+     * Check and create the specified collection if it doesn't exist.
+     */
+    checkCollection({ collection }: VQuery): Promise<boolean>;
+    /**
+     * Check if a collection exists.
+     */
+    issetCollection({ collection }: VQuery): Promise<boolean>;
+    /**
+     * Add a new entry to the specified database.
+     */
+    add({ collection, data, id_gen }: VQuery): Promise<import("../types/arg.js").Arg>;
+    /**
+     * Find entries in the specified database based on search criteria.
+     */
+    find({ collection, search, context, dbFindOpts, findOpts }: VQuery): Promise<Data[]>;
+    /**
+     * Find the first matching entry in the specified database based on search criteria.
+     */
+    findOne({ collection, search, context, findOpts }: VQuery): Promise<Data>;
+    /**
+     * Update entries in the specified database based on search criteria and an updater function or object.
+     */
+    update({ collection, search, updater, context }: VQuery): Promise<boolean>;
+    /**
+     * Update the first matching entry in the specified database based on search criteria and an updater function or object.
+     */
+    updateOne({ collection, search, updater, context }: VQuery): Promise<boolean>;
+    /**
+     * Remove entries from the specified database based on search criteria.
+     */
+    remove({ collection, search, context }: VQuery): Promise<boolean>;
+    /**
+     * Remove the first matching entry from the specified database based on search criteria.
+     */
+    removeOne({ collection, search, context }: VQuery): Promise<boolean>;
+    /**
+     * Removes a database collection from the file system.
+     */
+    removeCollection({ collection }: VQuery): Promise<boolean>;
+}
+export default class ValtheraMemory extends ValtheraClass {
+    constructor(...args: any[]);
+}
+export declare function createMemoryValthera<T = {
+    [key: string]: Data[];
+}>(data?: T): ValtheraMemory;

package/dist/db/memory.js

@@ -0,0 +1,145 @@
+import ValtheraClass from "./valthera.js";
+import CustomFileCpu from "../customFileCpu.js";
+import genId from "../helpers/gen.js";
+import dbActionBase from "../base/actions.js";
+import { compareSafe } from "../utils/sort.js";
+export class MemoryAction extends dbActionBase {
+    folder;
+    options;
+    fileCpu;
+    memory;
+    /**
+     * Creates a new instance of dbActionC.
+     * @constructor
+     * @param folder - The folder where database files are stored.
+     * @param options - The options object.
+     */
+    constructor() {
+        super();
+        this.memory = new Map();
+        this.fileCpu = new CustomFileCpu(this._readMemory.bind(this), this._writeMemory.bind(this));
+    }
+    _readMemory(key) {
+        if (!this.memory.has(key))
+            return [];
+        return this.memory.get(key);
+    }
+    _writeMemory(key, data) {
+        this.memory.set(key, data);
+    }
+    _getCollectionPath(collection) {
+        return this.folder + "/" + collection + "/";
+    }
+    /**
+     * Get a list of available databases in the specified folder.
+     */
+    async getCollections() {
+        const collections = Array.from(this.memory.keys());
+        return collections;
+    }
+    /**
+     * Check and create the specified collection if it doesn't exist.
+     */
+    async checkCollection({ collection }) {
+        if (this.issetCollection(collection))
+            return;
+        this.memory.set(collection, []);
+        return true;
+    }
+    /**
+     * Check if a collection exists.
+     */
+    async issetCollection({ collection }) {
+        return this.memory.has(collection);
+    }
+    /**
+     * Add a new entry to the specified database.
+     */
+    async add({ collection, data, id_gen = true }) {
+        await this.checkCollection(arguments[0]);
+        if (id_gen)
+            data._id = data._id || genId();
+        await this.fileCpu.add(collection, data);
+        return data;
+    }
+    /**
+     * Find entries in the specified database based on search criteria.
+     */
+    async find({ collection, search, context = {}, dbFindOpts = {}, findOpts = {} }) {
+        const { reverse = false, max = -1, offset = 0, sortBy, sortAsc = true } = dbFindOpts;
+        await this.checkCollection(arguments[0]);
+        let data = await this.fileCpu.find(collection, search, context, findOpts);
+        if (reverse)
+            data.reverse();
+        if (sortBy) {
+            const dir = sortAsc ? 1 : -1;
+            data.sort((a, b) => compareSafe(a[sortBy], b[sortBy]) * dir);
+        }
+        if (offset > 0) {
+            if (data.length <= offset)
+                return [];
+            data = data.slice(offset);
+        }
+        if (max !== -1 && data.length > max) {
+            data = data.slice(0, max);
+        }
+        return data;
+    }
+    /**
+     * Find the first matching entry in the specified database based on search criteria.
+     */
+    async findOne({ collection, search, context = {}, findOpts = {} }) {
+        await this.checkCollection(arguments[0]);
+        let data = await this.fileCpu.findOne(collection, search, context, findOpts);
+        return data || null;
+    }
+    /**
+     * Update entries in the specified database based on search criteria and an updater function or object.
+     */
+    async update({ collection, search, updater, context = {} }) {
+        await this.checkCollection(arguments[0]);
+        return await this.fileCpu.update(collection, false, search, updater, context);
+    }
+    /**
+     * Update the first matching entry in the specified database based on search criteria and an updater function or object.
+     */
+    async updateOne({ collection, search, updater, context = {} }) {
+        await this.checkCollection(arguments[0]);
+        return await this.fileCpu.update(collection, true, search, updater, context);
+    }
+    /**
+     * Remove entries from the specified database based on search criteria.
+     */
+    async remove({ collection, search, context = {} }) {
+        await this.checkCollection(arguments[0]);
+        return await this.fileCpu.remove(collection, false, search, context);
+    }
+    /**
+     * Remove the first matching entry from the specified database based on search criteria.
+     */
+    async removeOne({ collection, search, context = {} }) {
+        await this.checkCollection(arguments[0]);
+        return await this.fileCpu.remove(collection, true, search, context);
+    }
+    /**
+     * Removes a database collection from the file system.
+     */
+    async removeCollection({ collection }) {
+        this.memory.delete(collection);
+        return true;
+    }
+}
+export default class ValtheraMemory extends ValtheraClass {
+    constructor(...args) {
+        super({ dbAction: new MemoryAction() });
+    }
+}
+export function createMemoryValthera(data) {
+    const db = new ValtheraMemory();
+    if (!data)
+        return db;
+    for (const collection of Object.keys(data)) {
+        db.dbAction.memory.set(collection, data[collection]);
+    }
+    return db;
+}