@wxn0brp/vql 0.4.0 → 0.4.3

package/dist/falconFrame.d.ts

@@ -4,6 +4,7 @@ type ContextFn = (req: FFRequest) => Promise<any> | any;
 interface FF_VQL_Options {
     path?: string;
     getUser?: ContextFn;
+    dev?: boolean;
 }
 export declare function FF_VQL(app: FalconFrame, processor: VQLProcessor, options?: FF_VQL_Options): void;
 export {};

package/dist/falconFrame.js

@@ -1,3 +1,4 @@
+import { parseStringQuery } from "./cpu/string/index.js";
 export function FF_VQL(app, processor, options = {}) {
     const path = options.path || "/VQL";
     const getContext = options.getUser || (() => ({}));
@@ -14,4 +15,15 @@ export function FF_VQL(app, processor, options = {}) {
             return { err: true, msg: e.message };
         }
     });
+    if (options.dev) {
+        app.get(path + "-query", (req, res) => {
+            try {
+                return res.json(parseStringQuery(req.query?.query || ""));
+            }
+            catch (e) {
+                res.status(500);
+                return { err: true, msg: e.message };
+            }
+        });
+    }
 }

package/dist/processor.d.ts

@@ -9,5 +9,5 @@ export declare class VQLProcessor<GW = any> {
     relation: Relation;
     preDefinedSheets: Map<string, VQL>;
     constructor(dbInstances: Record<string, ValtheraCompatible>, gw?: GateWarden<GW>, config?: VQLConfig);
-    execute<T = any>(queryRaw: VqlQueryRaw, user: any): Promise<T | VQLError>;
+    execute<T = any>(queryRaw: VqlQueryRaw<T>, user: any): Promise<T | VQLError>;
 }

package/dist/processor.js

@@ -4,7 +4,7 @@ import { executeRelation } from "./cpu/relation.js";
 import { executeQuery } from "./cpu/request.js";
 import { parseStringQuery } from "./cpu/string/index.js";
 import logger from "./logger.js";
-import { executeSheet } from "./sheet/index.js";
+import { executeSheetAndReplaceVars } from "./sheet/index.js";
 import { validateRaw, validateVql } from "./valid.js";
 export class VQLProcessor {
     dbInstances;
@@ -48,7 +48,7 @@ export class VQLProcessor {
             logger.warn("Raw validation failed:", validateRawResult);
             return validateRawResult;
         }
-        const query = executeSheet(queryRaw, this.preDefinedSheets);
+        const query = executeSheetAndReplaceVars(queryRaw, this.preDefinedSheets, user);
         logger.debug("Executed sheet (expanded query):", query);
         const validateVqlResult = validateVql(this.config, query);
         if (validateVqlResult !== true) {

package/dist/sheet/index.d.ts

@@ -1,2 +1,2 @@
 import { VQL, VQLR } from "../types/vql.js";
-export declare function executeSheet(query: VQLR, preDefinedSheets: Map<string, VQL>): VQL;
+export declare function executeSheetAndReplaceVars(query: VQLR, preDefinedSheets: Map<string, VQL>, user: any): VQL;

package/dist/sheet/index.js

@@ -46,7 +46,7 @@ function replaceVariables(obj, variables) {
     }
     return obj;
 }
-export function executeSheet(query, preDefinedSheets) {
+export function executeSheetAndReplaceVars(query, preDefinedSheets, user) {
     if ("ref" in query) {
         if (preDefinedSheets.has(query.ref)) {
             const ref = preDefinedSheets.get(query.ref);
@@ -56,9 +56,15 @@ export function executeSheet(query, preDefinedSheets) {
         }
         delete query.ref;
     }
-    if ("var" in query) {
-        query = replaceVariables(query, query.var);
-        delete query.var;
-    }
+    query.var = {
+        _me: user?.id || user?._id || user,
+        _now: Date.now(),
+        _nowShort: Math.floor(Date.now() / 1000),
+        __now: Date.now().toString(),
+        __nowShort: Math.floor(Date.now() / 1000).toString(),
+        ...(query.var || {})
+    };
+    query = replaceVariables(query, query.var);
+    delete query.var;
     return query;
 }

package/dist/types/vql.d.ts

@@ -2,39 +2,39 @@ import { RelationTypes } from "@wxn0brp/db";
 import { Search, Arg } from "@wxn0brp/db-core/types/arg";
 import { DbFindOpts, FindOpts } from "@wxn0brp/db-core/types/options";
 import { UpdaterArg } from "@wxn0brp/db-core/types/updater";
-export type VQLQuery = {
-    find: VQLFind;
-    findOne: VQLFindOne;
-    f: VQLFindOne;
-    add: VQLAdd;
-    update: VQLUpdate;
-    updateOne: VQLUpdateOne;
-    remove: VQLRemove;
-    removeOne: VQLRemoveOne;
-    updateOneOrAdd: VQLUpdateOneOrAdd;
+export interface VQLQuery<T = any> {
+    find: VQLFind<T>;
+    findOne: VQLFindOne<T>;
+    f: VQLFindOne<T>;
+    add: VQLAdd<T>;
+    update: VQLUpdate<T>;
+    updateOne: VQLUpdateOne<T>;
+    remove: VQLRemove<T>;
+    removeOne: VQLRemoveOne<T>;
+    updateOneOrAdd: VQLUpdateOneOrAdd<T>;
     removeCollection: VQLCollectionOperation;
     checkCollection: VQLCollectionOperation;
     issetCollection: VQLCollectionOperation;
     getCollections: {};
-};
-export type VQLQueryData = {
-    find: VQLFind;
+}
+export type VQLQueryData<T = any> = {
+    find: VQLFind<T>;
 } | {
-    findOne: VQLFindOne;
+    findOne: VQLFindOne<T>;
 } | {
-    f: VQLFindOne;
+    f: VQLFindOne<T>;
 } | {
-    add: VQLAdd;
+    add: VQLAdd<T>;
 } | {
-    update: VQLUpdate;
+    update: VQLUpdate<T>;
 } | {
-    updateOne: VQLUpdateOne;
+    updateOne: VQLUpdateOne<T>;
 } | {
-    remove: VQLRemove;
+    remove: VQLRemove<T>;
 } | {
-    removeOne: VQLRemoveOne;
+    removeOne: VQLRemoveOne<T>;
 } | {
-    updateOneOrAdd: VQLUpdateOneOrAdd;
+    updateOneOrAdd: VQLUpdateOneOrAdd<T>;
 } | {
     removeCollection: VQLCollectionOperation;
 } | {
@@ -44,56 +44,56 @@ export type VQLQueryData = {
 } | {
     getCollections: {};
 };
-export interface VQLRequest {
+export interface VQLRequest<T = any> {
     db: string;
-    d: VQLQueryData;
+    d: VQLQueryData<T>;
 }
-export interface VQLFind {
+export interface VQLFind<T = any> {
     collection: string;
-    search?: Search;
+    search?: Search<T>;
     limit?: number;
     fields?: VQLFields;
     select?: VQLFields;
     relations?: VQLRelations;
-    options?: DbFindOpts;
-    searchOpts?: FindOpts;
+    options?: DbFindOpts<T>;
+    searchOpts?: FindOpts<T>;
 }
-export interface VQLFindOne {
+export interface VQLFindOne<T = any> {
     collection: string;
-    search: Search;
+    search: Search<T>;
     fields?: VQLFields;
     select?: VQLFields;
     relations?: VQLRelations;
-    searchOpts?: FindOpts;
+    searchOpts?: FindOpts<T>;
 }
-export interface VQLAdd {
+export interface VQLAdd<T = any> {
     collection: string;
-    data: Arg;
+    data: Arg<T>;
     id_gen?: boolean;
 }
-export interface VQLUpdate {
+export interface VQLUpdate<T = any> {
     collection: string;
-    search: Search;
-    updater: UpdaterArg;
+    search: Search<T>;
+    updater: UpdaterArg<T>;
 }
-export interface VQLUpdateOne {
+export interface VQLUpdateOne<T = any> {
     collection: string;
-    search: Search;
-    updater: UpdaterArg;
+    search: Search<T>;
+    updater: UpdaterArg<T>;
 }
-export interface VQLRemove {
+export interface VQLRemove<T = any> {
     collection: string;
-    search: Search;
+    search: Search<T>;
 }
-export interface VQLRemoveOne {
+export interface VQLRemoveOne<T = any> {
     collection: string;
-    search: Search;
+    search: Search<T>;
 }
-export interface VQLUpdateOneOrAdd {
+export interface VQLUpdateOneOrAdd<T = any> {
     collection: string;
-    search: Search;
-    updater: UpdaterArg;
-    add_arg?: Arg;
+    search: Search<T>;
+    updater: UpdaterArg<T>;
+    add_arg?: Arg<T>;
     id_gen?: boolean;
 }
 export interface VQLCollectionOperation {
@@ -121,15 +121,15 @@ type VQLRefRequired = VQLRef & Required<Pick<VQLRef, "ref">>;
 type DeepPartial<T> = {
     [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
 };
-export type VQL = (VQLRequest | RelationQuery) & VQLRef;
-export type VQLR = VQL | (DeepPartial<VQL> & VQLRefRequired) | VQLRefRequired;
+export type VQL<T = any> = (VQLRequest<T> | RelationQuery) & VQLRef;
+export type VQLR<T = any> = VQL<T> | (DeepPartial<VQL<T>> & VQLRefRequired) | VQLRefRequired;
 export interface VQLError {
     err: true;
     msg: string;
     c: number;
     why?: string;
 }
-export type VqlQueryRaw = VQLR | string | {
+export type VqlQueryRaw<T = any> = VQLR<T> | string | {
     query: string;
 } & VQLRef;
 export {};

package/dist/vql.d.ts

@@ -1,114 +1,111 @@
 // Generated by dts-bundle-generator v9.5.1
 
-export type Id = string;
+export interface Data {
+	[key: string]: any;
+}
+export interface VContext {
+	[key: string]: any;
+}
+export type KeysMatching<T, V, C = V> = {
+	[K in keyof T]-?: T[K] extends C ? K : never;
+}[keyof T];
+export type PartialOfType<T, V, C = V> = Partial<Record<KeysMatching<T, V, C>, V>>;
+export type PartialPickMatching<T, V, C = V> = Partial<Pick<T, KeysMatching<T, V, C>>>;
 /** Logical Operators */
-export type LogicalOperators = {
+export type LogicalOperators<T = any> = {
 	/**
 	 * Recursively applies multiple conditions, all of which must evaluate to true.
 	 * Can include other operators such as $gt, $exists, or nested $and/$or conditions.
 	 */
-	$and?: Array<SearchOptions>;
+	$and?: Array<SearchOptions<T>>;
 	/**
 	 * Recursively applies multiple conditions, at least one of which must evaluate to true.
 	 * Can include other operators such as $lt, $type, or nested $and/$or conditions.
 	 */
-	$or?: Array<SearchOptions>;
+	$or?: Array<SearchOptions<T>>;
 	/**
 	 * Negates a single condition.
 	 * Can include any other operator as its value.
 	 */
-	$not?: SearchOptions;
+	$not?: SearchOptions<T>;
 };
 /** Comparison Operators */
-export type ComparisonOperators = {
-	$gt?: Record<string, number>;
-	$lt?: Record<string, number>;
-	$gte?: Record<string, number>;
-	$lte?: Record<string, number>;
-	$in?: Record<string, any[]>;
-	$nin?: Record<string, any[]>;
-	$between?: Record<string, [
+export type ComparisonOperators<T = any> = {
+	$gt?: PartialOfType<T, number>;
+	$lt?: PartialOfType<T, number>;
+	$gte?: PartialOfType<T, number>;
+	$lte?: PartialOfType<T, number>;
+	$between?: PartialOfType<T, [
 		number,
 		number
-	]>;
+	], number>;
+	$in?: Partial<Record<keyof T, T[keyof T][]>>;
+	$nin?: Partial<Record<keyof T, T[keyof T][]>>;
 };
 /** Type and Existence Operators */
-export type TypeAndExistenceOperators = {
-	$exists?: Record<string, boolean>;
-	$type?: Record<string, string>;
+export type TypeAndExistenceOperators<T = any> = {
+	$exists?: PartialOfType<T, boolean, any>;
+	$type?: PartialOfType<T, string>;
 };
 /** Array Operators */
-export type ArrayOperators = {
-	$arrinc?: Record<string, any[]>;
-	$arrincall?: Record<string, any[]>;
-	$size?: Record<string, number>;
+export type ArrayOperators<T = any> = {
+	$arrinc?: PartialPickMatching<T, any[]>;
+	$arrincall?: PartialPickMatching<T, any[]>;
+	$size?: PartialOfType<T, number>;
 };
 /** String Operators */
-export type StringOperators = {
-	$regex?: Record<string, RegExp>;
-	$startsWith?: Record<string, string>;
-	$endsWith?: Record<string, string>;
+export type StringOperators<T = any> = {
+	$regex?: PartialOfType<T, RegExp, string>;
+	$startsWith?: PartialOfType<T, string>;
+	$endsWith?: PartialOfType<T, string>;
 };
 /** Other Operators */
-export type OtherOperators = {
-	$subset?: Record<string, any>;
+export type OtherOperators<T = any> = {
+	$subset?: Partial<Record<keyof T, T[keyof T]>>;
 };
 /** Predefined Search Operators */
-export type PredefinedSearchOperators = LogicalOperators & ComparisonOperators & TypeAndExistenceOperators & ArrayOperators & StringOperators & OtherOperators;
+export type PredefinedSearchOperators<T = any> = LogicalOperators<T> & ComparisonOperators<T> & TypeAndExistenceOperators<T> & ArrayOperators<T> & StringOperators<T> & OtherOperators<T>;
 /**
  * SearchOptions can be either a function or an object with predefined operators.
  */
-export type SearchOptions = PredefinedSearchOperators & Arg;
-export interface VContext {
-	[key: string]: any;
-}
-/**
- * Predefined type for updating data.
- */
+export type SearchOptions<T = any> = PredefinedSearchOperators<T> & Arg<T>;
 /** Arrays */
-export type ArrayUpdater = {
-	$push?: any;
+export type ArrayUpdater<T = any> = {
+	$push?: PartialOfType<T, any>;
 	/** Pushes items into an array and removes duplicates */
-	$pushset?: any;
-	$pull?: any;
-	$pullall?: any;
+	$pushset?: PartialOfType<T, any>;
+	$pull?: PartialOfType<T, any>;
+	$pullall?: PartialOfType<T, any>;
 };
 /** Objects */
-export type ObjectUpdater = {
-	$merge?: any;
+export type ObjectUpdater<T = any> = {
+	$merge?: PartialOfType<T, any[]>;
 };
 /** Values */
-export type ValueUpdater = {
-	$set?: any;
-	$inc?: any;
-	$dec?: any;
-	$unset?: any;
-	$rename?: any;
-};
-export type UpdaterArg = ArrayUpdater & ObjectUpdater & ValueUpdater & {
-	[key: string]: any;
+export type ValueUpdater<T = any> = {
+	$inc?: PartialOfType<T, number>;
+	$dec?: PartialOfType<T, number>;
+	$unset?: PartialOfType<T, any>;
+	$rename?: PartialOfType<T, any>;
 };
-export interface Arg {
-	_id?: Id;
-	[key: string]: any;
-}
+export type UpdaterArg<T = any> = ArrayUpdater<T> & ObjectUpdater<T> & ValueUpdater<T> & Arg<T>;
+export type Arg<T = any> = {
+	[K in keyof T]?: any;
+} & Record<string, any>;
 export type SearchFunc<T = any> = (data: T, context: VContext) => boolean;
 export type UpdaterFunc<T = any> = (data: T, context: VContext) => boolean;
-export type Search<T = any> = SearchOptions | SearchFunc<T>;
-export type Updater<T = any> = UpdaterArg | UpdaterArg[] | UpdaterFunc<T>;
-export interface Data {
-	[key: string]: any;
-}
-export interface DbFindOpts {
+export type Search<T = any> = SearchOptions<T> | SearchFunc<T>;
+export type Updater<T = any> = UpdaterArg<T> | UpdaterArg<T>[] | UpdaterFunc<T>;
+export interface DbFindOpts<T = any> {
 	reverse?: boolean;
 	max?: number;
 	offset?: number;
-	sortBy?: string;
+	sortBy?: KeysMatching<T, any>;
 	sortAsc?: boolean;
 }
-export interface FindOpts {
-	select?: string[];
-	exclude?: string[];
+export interface FindOpts<T = any> {
+	select?: KeysMatching<T, any>[];
+	exclude?: KeysMatching<T, any>[];
 	transform?: Function;
 }
 declare class CollectionManager {
@@ -153,15 +150,15 @@ export interface ValtheraCompatible {
 	getCollections(): Promise<string[]>;
 	checkCollection(collection: string): Promise<boolean>;
 	issetCollection(collection: string): Promise<boolean>;
-	add<T = Data>(collection: string, data: Arg, id_gen?: boolean): Promise<T>;
-	find<T = Data>(collection: string, search: Search, context?: VContext, options?: DbFindOpts, findOpts?: FindOpts): Promise<T[]>;
-	findOne<T = Data>(collection: string, search: Search, context?: VContext, findOpts?: FindOpts): Promise<T | null>;
-	update(collection: string, search: Search, updater: Updater, context?: VContext): Promise<boolean>;
-	updateOne(collection: string, search: Search, updater: Updater, context?: VContext): Promise<boolean>;
-	remove(collection: string, search: Search, context?: VContext): Promise<boolean>;
-	removeOne(collection: string, search: Search, context?: VContext): Promise<boolean>;
+	add<T = Data>(collection: string, data: Arg<T>, id_gen?: boolean): Promise<T>;
+	find<T = Data>(collection: string, search: Search<T>, context?: VContext, options?: DbFindOpts<T>, findOpts?: FindOpts<T>): Promise<T[]>;
+	findOne<T = Data>(collection: string, search: Search<T>, context?: VContext, findOpts?: FindOpts<T>): Promise<T | null>;
+	update<T = Data>(collection: string, search: Search<T>, updater: Updater<T>, context?: VContext): Promise<boolean>;
+	updateOne<T = Data>(collection: string, search: Search<T>, updater: Updater<T>, context?: VContext): Promise<boolean>;
+	remove<T = Data>(collection: string, search: Search<T>, context?: VContext): Promise<boolean>;
+	removeOne<T = Data>(collection: string, search: Search<T>, context?: VContext): Promise<boolean>;
 	removeCollection(collection: string): Promise<boolean>;
-	updateOneOrAdd(collection: string, search: Search, updater: Updater, add_arg?: Arg, context?: VContext, id_gen?: boolean): Promise<boolean>;
+	updateOneOrAdd<T = Data>(collection: string, search: Search<T>, updater: Updater<T>, add_arg?: Arg<T>, context?: VContext, id_gen?: boolean): Promise<boolean>;
 }
 declare namespace RelationTypes {
 	type Path = [
@@ -192,39 +189,39 @@ declare namespace RelationTypes {
 		};
 	}
 }
-export type VQLQuery = {
-	find: VQLFind;
-	findOne: VQLFindOne;
-	f: VQLFindOne;
-	add: VQLAdd;
-	update: VQLUpdate;
-	updateOne: VQLUpdateOne;
-	remove: VQLRemove;
-	removeOne: VQLRemoveOne;
-	updateOneOrAdd: VQLUpdateOneOrAdd;
+export interface VQLQuery<T = any> {
+	find: VQLFind<T>;
+	findOne: VQLFindOne<T>;
+	f: VQLFindOne<T>;
+	add: VQLAdd<T>;
+	update: VQLUpdate<T>;
+	updateOne: VQLUpdateOne<T>;
+	remove: VQLRemove<T>;
+	removeOne: VQLRemoveOne<T>;
+	updateOneOrAdd: VQLUpdateOneOrAdd<T>;
 	removeCollection: VQLCollectionOperation;
 	checkCollection: VQLCollectionOperation;
 	issetCollection: VQLCollectionOperation;
 	getCollections: {};
-};
-export type VQLQueryData = {
-	find: VQLFind;
+}
+export type VQLQueryData<T = any> = {
+	find: VQLFind<T>;
 } | {
-	findOne: VQLFindOne;
+	findOne: VQLFindOne<T>;
 } | {
-	f: VQLFindOne;
+	f: VQLFindOne<T>;
 } | {
-	add: VQLAdd;
+	add: VQLAdd<T>;
 } | {
-	update: VQLUpdate;
+	update: VQLUpdate<T>;
 } | {
-	updateOne: VQLUpdateOne;
+	updateOne: VQLUpdateOne<T>;
 } | {
-	remove: VQLRemove;
+	remove: VQLRemove<T>;
 } | {
-	removeOne: VQLRemoveOne;
+	removeOne: VQLRemoveOne<T>;
 } | {
-	updateOneOrAdd: VQLUpdateOneOrAdd;
+	updateOneOrAdd: VQLUpdateOneOrAdd<T>;
 } | {
 	removeCollection: VQLCollectionOperation;
 } | {
@@ -234,56 +231,56 @@ export type VQLQueryData = {
 } | {
 	getCollections: {};
 };
-export interface VQLRequest {
+export interface VQLRequest<T = any> {
 	db: string;
-	d: VQLQueryData;
+	d: VQLQueryData<T>;
 }
-export interface VQLFind {
+export interface VQLFind<T = any> {
 	collection: string;
-	search?: Search;
+	search?: Search<T>;
 	limit?: number;
 	fields?: VQLFields;
 	select?: VQLFields;
 	relations?: VQLRelations;
-	options?: DbFindOpts;
-	searchOpts?: FindOpts;
+	options?: DbFindOpts<T>;
+	searchOpts?: FindOpts<T>;
 }
-export interface VQLFindOne {
+export interface VQLFindOne<T = any> {
 	collection: string;
-	search: Search;
+	search: Search<T>;
 	fields?: VQLFields;
 	select?: VQLFields;
 	relations?: VQLRelations;
-	searchOpts?: FindOpts;
+	searchOpts?: FindOpts<T>;
 }
-export interface VQLAdd {
+export interface VQLAdd<T = any> {
 	collection: string;
-	data: Arg;
+	data: Arg<T>;
 	id_gen?: boolean;
 }
-export interface VQLUpdate {
+export interface VQLUpdate<T = any> {
 	collection: string;
-	search: Search;
-	updater: UpdaterArg;
+	search: Search<T>;
+	updater: UpdaterArg<T>;
 }
-export interface VQLUpdateOne {
+export interface VQLUpdateOne<T = any> {
 	collection: string;
-	search: Search;
-	updater: UpdaterArg;
+	search: Search<T>;
+	updater: UpdaterArg<T>;
 }
-export interface VQLRemove {
+export interface VQLRemove<T = any> {
 	collection: string;
-	search: Search;
+	search: Search<T>;
 }
-export interface VQLRemoveOne {
+export interface VQLRemoveOne<T = any> {
 	collection: string;
-	search: Search;
+	search: Search<T>;
 }
-export interface VQLUpdateOneOrAdd {
+export interface VQLUpdateOneOrAdd<T = any> {
 	collection: string;
-	search: Search;
-	updater: UpdaterArg;
-	add_arg?: Arg;
+	search: Search<T>;
+	updater: UpdaterArg<T>;
+	add_arg?: Arg<T>;
 	id_gen?: boolean;
 }
 export interface VQLCollectionOperation {
@@ -311,15 +308,15 @@ export type VQLRefRequired = VQLRef & Required<Pick<VQLRef, "ref">>;
 export type DeepPartial<T> = {
 	[P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
 };
-export type VQL = (VQLRequest | RelationQuery) & VQLRef;
-export type VQLR = VQL | (DeepPartial<VQL> & VQLRefRequired) | VQLRefRequired;
+export type VQL<T = any> = (VQLRequest<T> | RelationQuery) & VQLRef;
+export type VQLR<T = any> = VQL<T> | (DeepPartial<VQL<T>> & VQLRefRequired) | VQLRefRequired;
 export interface VQLError {
 	err: true;
 	msg: string;
 	c: number;
 	why?: string;
 }
-export type VqlQueryRaw = VQLR | string | {
+export type VqlQueryRaw<T = any> = VQLR<T> | string | {
 	query: string;
 } & VQLRef;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/vql",
-  "version": "0.4.0",
+  "version": "0.4.3",
   "main": "dist/index.js",
   "author": "wxn0brP",
   "license": "MIT",
@@ -16,7 +16,7 @@
   ],
   "peerDependencies": {
     "@wxn0brp/db-core": ">=0.0.1 <0.1.0",
-    "@wxn0brp/falcon-frame": ">=0.0.14"
+    "@wxn0brp/falcon-frame": ">=0.0.18"
   },
   "peerDependenciesMeta": {
     "@wxn0brp/falcon-frame": {
@@ -37,7 +37,6 @@
     "typescript-json-schema": "^0.65.1"
   },
   "dependencies": {
-    "@wxn0brp/db-core": "^0.0.2",
     "@wxn0brp/gate-warden": ">=0.3.0",
     "@wxn0brp/lucerna-log": "^0.1.1",
     "ajv": "^8.17.1",