document-dataply 0.0.1

package/dist/types/core/bptree/documentComparator.d.ts

@@ -0,0 +1,7 @@
+import { ValueComparator } from 'dataply';
+import type { DataplyTreeValue, Primitive } from '../../types';
+export declare class DocumentValueComparator<T extends DataplyTreeValue<U>, U extends Primitive> extends ValueComparator<T> {
+    primaryAsc(a: T, b: T): number;
+    asc(a: T, b: T): number;
+    match(value: T): string;
+}

package/dist/types/core/bptree/documentStrategy.d.ts

@@ -0,0 +1,15 @@
+import type { DataplyTreeValue, Primitive } from '../../types';
+import { BPTreeNode, SerializeStrategyAsync, type SerializeStrategyHead } from 'dataply';
+import { DocumentDataplyAPI } from '../document';
+export declare class DocumentSerializeStrategyAsync<T extends Primitive> extends SerializeStrategyAsync<number, DataplyTreeValue<T>> {
+    protected readonly api: DocumentDataplyAPI<any>;
+    protected readonly txContext: DocumentDataplyAPI<any>['txContext'];
+    protected readonly treeKey: string;
+    constructor(order: number, api: DocumentDataplyAPI<any>, txContext: DocumentDataplyAPI<any>['txContext'], treeKey: string);
+    id(isLeaf: boolean): Promise<string>;
+    read(id: string): Promise<BPTreeNode<number, DataplyTreeValue<T>>>;
+    write(id: string, node: BPTreeNode<number, DataplyTreeValue<T>>): Promise<void>;
+    delete(id: string): Promise<void>;
+    readHead(): Promise<SerializeStrategyHead | null>;
+    writeHead(head: SerializeStrategyHead): Promise<void>;
+}

package/dist/types/core/document.d.ts

@@ -0,0 +1,50 @@
+import type { DataplyTreeValue, DocumentDataplyMetadata, DocumentDataplyOptions, DocumentJSON, FlattenedDocumentJSON, Primitive, DocumentDataplyQuery, FinalFlatten, DocumentDataplyCondition, DataplyDocument } from '../types';
+import { DataplyAPI, Transaction, BPTreeAsync } from 'dataply';
+import { DocumentValueComparator } from './bptree/documentComparator';
+export declare class DocumentDataplyAPI<T extends DocumentJSON> extends DataplyAPI {
+    runWithDefault: <T_1>(callback: (tx: Transaction) => Promise<T_1>, tx?: Transaction) => Promise<T_1>;
+    treeHeads: DocumentDataplyMetadata['treeHeads'];
+    readonly trees: Map<string, BPTreeAsync<number, DataplyTreeValue<Primitive>>>;
+    readonly comparator: DocumentValueComparator<DataplyTreeValue<Primitive>, Primitive>;
+    constructor(file: string, options: DocumentDataplyOptions);
+    ensureTree<T extends Primitive>(field: string): Promise<BPTreeAsync<number, DataplyTreeValue<T>>>;
+    createDocumentMetadata(): DocumentDataplyMetadata;
+    initializeDocumentFile(tx: Transaction): Promise<void>;
+    verifyDocumentFile(tx: Transaction): Promise<boolean>;
+    /**
+     * returns flattened document
+     * @param document
+     * @returns
+     */
+    flattenDocument(document: T): FlattenedDocumentJSON;
+    getDocumentMetadata(tx: Transaction): Promise<DocumentDataplyMetadata>;
+    updateDocumentMetadata(metadata: DocumentDataplyMetadata, tx: Transaction): Promise<void>;
+    updateTreeHead(tx: Transaction): Promise<void>;
+}
+export declare class DocumentDataply<T extends DocumentJSON> {
+    protected readonly api: DocumentDataplyAPI<T>;
+    private readonly operatorConverters;
+    constructor(file: string, options?: DocumentDataplyOptions);
+    init(): Promise<void>;
+    createTransaction(): Transaction;
+    private verboseQuery;
+    /**
+     * Return optimized tree for query
+     * @param query
+     * @returns
+     */
+    getSelectivityCandidate<U extends FinalFlatten<DataplyDocument<T>>, V extends DataplyTreeValue<U>>(query: Partial<DocumentDataplyQuery<V>>): Promise<{
+        driver: {
+            tree: BPTreeAsync<number, V>;
+            condition: Partial<DocumentDataplyCondition<U>>;
+        };
+        others: {
+            tree: BPTreeAsync<number, V>;
+            condition: Partial<DocumentDataplyCondition<U>>;
+        }[];
+    } | null>;
+    private insertDocument;
+    insert(document: T, tx?: Transaction): Promise<boolean>;
+    select(query: Partial<DocumentDataplyQuery<FinalFlatten<DataplyDocument<T>>>>, limit?: number, tx?: Transaction): Promise<DataplyDocument<T>[]>;
+    close(): Promise<void>;
+}

package/dist/types/core/index.d.ts

@@ -0,0 +1,2 @@
+export { DocumentDataply } from './document';
+export { Transaction, GlobalTransaction } from 'dataply';

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export * from './core';

package/dist/types/types/index.d.ts

@@ -0,0 +1,55 @@
+import type { DataplyOptions, SerializeStrategyHead } from 'dataply';
+export type Primitive = string | number | boolean | null;
+export type JSONValue = Primitive | JSONValue[] | {
+    [key: string]: JSONValue;
+};
+export type DocumentJSON = {
+    [key: string]: JSONValue;
+};
+export type FlattenedDocumentJSON = {
+    [key: string]: Primitive;
+};
+export interface DocumentDataplyMetadata {
+    magicString: string;
+    version: number;
+    createdAt: number;
+    updatedAt: number;
+    lastId: number;
+    treeHeads: Record<string, SerializeStrategyHead>;
+}
+export type DataplyDocumentBase = {
+    _id: number;
+};
+export type DataplyDocument<T extends DocumentJSON> = DataplyDocumentBase & T;
+export type DocumentDataplyCondition<V> = {
+    lt?: Partial<V>;
+    lte?: Partial<V>;
+    gt?: Partial<V>;
+    gte?: Partial<V>;
+    equal?: Partial<V>;
+    notEqual?: Partial<V>;
+    like?: Partial<V>;
+};
+export type DocumentDataplyQuery<T> = {
+    [key in keyof T]: T[key] | DocumentDataplyCondition<T[key]>;
+};
+export interface DataplyTreeValue<T> {
+    k: number;
+    v: T;
+}
+/**
+ * T가 객체인지 확인하고, 객체라면 하위 키를 재귀적으로 탐색합니다.
+ */
+type DeepFlattenKeys<T, Prefix extends string = ""> = T extends object ? {
+    [K in keyof T & string]: NonNullable<T[K]> extends object ? DeepFlattenKeys<NonNullable<T[K]>, `${Prefix}${K}.`> : `${Prefix}${K}`;
+}[keyof T & string] : Prefix extends `${infer P}.` ? P : "";
+/**
+ * 경로 문자열(Path)을 기반으로 원본 객체(T)에서 타입을 찾아옵니다.
+ */
+type GetTypeByPath<T, Path extends string> = Path extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? GetTypeByPath<NonNullable<T[Key]>, Rest> : never : Path extends keyof T ? T[Path] : never;
+export type FinalFlatten<T> = {
+    [P in DeepFlattenKeys<T>]: GetTypeByPath<T, P & string>;
+};
+export interface DocumentDataplyOptions extends DataplyOptions {
+}
+export {};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "document-dataply",
+  "version": "0.0.1",
+  "description": "",
+  "license": "MIT",
+  "author": "izure <admin@izure.org>",
+  "type": "commonjs",
+  "main": "./dist/cjs/index.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "require": "./dist/cjs/index.js",
+      "import": "./dist/cjs/index.js"
+    }
+  },
+  "files": [
+    "dist/**/*"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/izure1/document-dataply.git"
+  },
+  "scripts": {
+    "test": "jest -i",
+    "build": "node build/index.js && tsc"
+  },
+  "dependencies": {
+    "dataply": "^0.0.14"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "esbuild": "^0.27.2",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.6",
+    "typescript": "^5.9.3"
+  }
+}