shadowly 1.0.4 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "shadowly",
-    "version": "1.0.4",
+    "version": "1.0.5",
     "description": "TypeScript JSON Database",
     "keywords": [
         "database",

package/src/class.ts

@@ -0,0 +1,178 @@
+import * as fs from "node:fs";
+import { ShadowlyError } from "./error";
+
+function isValidJson(text: string): boolean {
+    if (typeof text !== "string") return false;
+    try {
+        JSON.parse(text);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+type GetKey<T> =
+    T extends readonly any[] ? number :
+    T extends object ? keyof T :
+    never;
+
+type GetValue<T, K> =
+    T extends readonly (infer U)[] ? U :
+    T extends Record<PropertyKey, any> ? (K extends keyof T ? T[K] : never) :
+    never;
+
+type RemoveKey<T> =
+    T extends readonly any[] ? number :
+    T extends object ? keyof T :
+    never;
+
+export default class Shadowly<TRoot, TNode = TRoot> {
+    public readonly DB_PATH: string;
+    private readonly path: string;
+
+    private content: TNode;
+
+    private parent?: Shadowly<TRoot, any>;
+    private parentKey?: PropertyKey;
+
+    /**
+     * Shadowly의 새 인스턴스를 만듭니다.
+     * @param path JSON 파일 경로
+     */
+    constructor(path: string) {
+        this.path = path;
+        this.DB_PATH = path;
+
+        if (!fs.existsSync(path))
+            throw new ShadowlyError("ENOTFOUND", path + " not found.");
+
+        const file = fs.readFileSync(path, "utf-8");
+        if (!isValidJson(file))
+            throw new ShadowlyError("EINVALID", path + " is not valid.");
+
+        this.content = JSON.parse(file) as any;
+    }
+
+    /**
+     * 새 JSON을 만듭니다.
+     * @param path JSON 파일 경로
+     * @param isArray true면 []를 쓰고, false면 {}를 씁니다.
+     */
+    public static generateNewJson(path: string, isArray?: boolean) {
+        fs.writeFileSync(path, isArray ? "[]" : "{}", "utf-8");
+    }
+
+    private static create<TRoot, T>(
+        DB_PATH: string,
+        path: string,
+        content: T,
+        parent?: Shadowly<TRoot, any>,
+        parentKey?: PropertyKey
+    ): Shadowly<TRoot, T> {
+        const inst = Object.create(Shadowly.prototype) as Shadowly<TRoot, T>;
+        (inst as any).DB_PATH = DB_PATH;
+        (inst as any).path = path;
+        (inst as any).content = content;
+        (inst as any).parent = parent;
+        (inst as any).parentKey = parentKey;
+        return inst;
+    }
+
+    /**
+     * key로 이동합니다.  
+     * @param key 이동할 키 이름
+     * @returns 작업 수행 후 Shadowly 인스턴스
+     */
+    get<K extends GetKey<TNode>>(key: K): Shadowly<TRoot, GetValue<TNode, K>> {
+        const nextContent = (this.content as any)[key];
+        return Shadowly.create<TRoot, GetValue<TNode, K>>(
+            this.DB_PATH,
+            this.path,
+            nextContent,
+            this,
+            key as any
+        );
+    }
+
+    /**
+     * 현재 key의 value를 반환합니다.
+     * @returns 현재 key의 value
+     */
+    value(): TNode {
+        return this.content;
+    }
+
+    /**
+     * 현재 key에 값을 씁니다.
+     * @param value 쓸 값
+     * @returns 작업 수행 후 Shadowly 인스턴스
+     */
+    set(value: TNode): this {
+        this.content = value;
+
+        if (this.parent && this.parentKey !== undefined) {
+            (this.parent.content as any)[this.parentKey] = value;
+        }
+
+        this.persist();
+        return this;
+    }
+
+    /**
+     * key를 삭제합니다.
+     * @param key 삭제할 key
+     * @returns 작업 수행 후 Shadowly 인스턴스
+     */
+    remove<K extends RemoveKey<TNode>>(key: K): this {
+        const cur: any = this.content;
+
+        if (Array.isArray(cur)) {
+            const idx = key as unknown as number;
+            if (Number.isInteger(idx) && idx >= 0 && idx < cur.length) cur.splice(idx, 1);
+        } else if (cur && typeof cur === "object") {
+            delete cur[key as any];
+        } else {
+            throw new ShadowlyError("ETYPE", "Current value is not an object/array.");
+        }
+
+        this.persist();
+        return this;
+    }
+
+    /**
+     * 한 번 뒤로 이동합니다.
+     * @returns 작업 수행 후 Shadowly 인스턴스
+     */
+    back(): Shadowly<TRoot, any> {
+        return this.parent ?? this;
+    }
+
+    /**
+     * steps만큼 뒤로 이동합니다.
+     * @param steps 이동할 횟수
+     * @returns 작업 수행 후 Shadowly 인스턴스
+     */
+    up(steps: number = 1): Shadowly<TRoot, any> {
+        let cur: Shadowly<TRoot, any> = this;
+        for (let i = 0; i < steps; i++) {
+            if (!cur.parent) break;
+            cur = cur.parent;
+        }
+        return cur;
+    }
+
+    /**
+     * JSON의 루트로 이동합니다.
+     * @returns 작업 수행 후 Shadowly 인스턴스
+     */
+    root(): Shadowly<TRoot, TRoot> {
+        let cur: Shadowly<TRoot, any> = this;
+        while (cur.parent) cur = cur.parent;
+        return cur as Shadowly<TRoot, TRoot>;
+    }
+
+    private persist(): void {
+        const r = this.root();
+        fs.writeFileSync(r.DB_PATH, JSON.stringify(r.content, null, 2), "utf-8");
+    }
+}

package/src/error.ts

@@ -0,0 +1,15 @@
+export class ShadowlyError extends Error {
+    public readonly code!: string;
+
+    constructor(
+        code: string,
+        message: string
+    ) {
+        super(code + ": " + message);
+
+        this.name = "Shadowly";
+        this.code = code;
+
+        Error.captureStackTrace(this, this.constructor);
+    }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+import Shadowly from "./class";
+
+export default Shadowly;