@wxn0brp/gate-warden 0.4.0 → 0.5.0

package/README.md

@@ -13,9 +13,13 @@ Gate Warden is a lightweight access control library that supports ACL, RBAC, and
 Install the library using npm or yarn:
 
 ```bash
-yarn add @wxn0brp/gate-warden
+npm i @wxn0brp/gate-warden
 ```
 
+## DOCS
+
+See [Docs](https://wxn0brp.github.io/gate-warden/)
+
 ## Usage
 
 ### GateWarden
@@ -76,14 +80,6 @@ Set the `debugLog` level in `GateWarden` to enable debug messages:
 - `1`: Basic logs
 - `2`: Detailed logs
 
-## Project Structure
-
-- **src/warden.ts:** Core access control logic.
-- **src/user.ts:** User management.
-- **src/mgr.ts:** Role and rule management.
-- **src/types/system.ts:** Type definitions for roles, rules, and users.
-- **src/log.ts:** Logging utilities.
-
 ## License
 
 This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

package/dist/check.d.ts

@@ -0,0 +1,32 @@
+import { CheckParams } from "./types/check.js";
+/**
+ * Checks if a user has the given flag on the given entity by checking the entity's ACL.
+ * @param db The DB instance
+ * @param flag The flag to check
+ * @param user The user to check
+ * @param entityId The ID of the entity to check
+ * @returns If the user has the flag on the entity:
+ *   - 1 if the user has the flag
+ *   - 0 if the user does not have the flag
+ *   - -1 if the entity does not have an ACL
+ */
+export declare function aclCheck({ db, entityId, flag, user }: CheckParams): Promise<number>;
+/**
+ * Checks if a user has the given flag on the given entity by checking each role the user has.
+ * @param db The DB instance
+ * @param flag The flag to check
+ * @param user The user to check
+ * @param entityId The ID of the entity to check
+ * @returns If the user has the flag on the entity
+ */
+export declare function rbacCheck({ db, flag, user, entityId }: CheckParams): Promise<boolean>;
+/**
+ * ABAC (Attribute-Based Access Control) check
+ * @param db The DB instance
+ * @param entityId The ID of the entity to check
+ * @param flag The flag to check
+ * @param user The user to check
+ * @param debugLog The debug log level
+ * @returns `true` if access is granted, `false` otherwise
+ */
+export declare function abacCheck({ db, entityId, flag, user, debugLog }: CheckParams): Promise<boolean>;

package/dist/check.js

@@ -0,0 +1,97 @@
+import hasFieldsAdvanced from "@wxn0brp/db-core/utils/hasFieldsAdvanced";
+import { COLORS } from "./log.js";
+import { convertPath } from "./utils.js";
+/**
+ * Checks if a user has the given flag on the given entity by checking the entity's ACL.
+ * @param db The DB instance
+ * @param flag The flag to check
+ * @param user The user to check
+ * @param entityId The ID of the entity to check
+ * @returns If the user has the flag on the entity:
+ *   - 1 if the user has the flag
+ *   - 0 if the user does not have the flag
+ *   - -1 if the entity does not have an ACL
+ */
+export async function aclCheck({ db, entityId, flag, user }) {
+    if (!await db.issetCollection("acl/" + entityId))
+        return -1;
+    const rules = await db.find("acl/" + entityId, {
+        $or: [
+            { uid: user._id },
+            {
+                $not: {
+                    $exists: { "uid": true }
+                }
+            }
+        ]
+    });
+    if (rules.length === 0)
+        return -1;
+    for (const rule of rules) {
+        if (rule.p & flag)
+            return 1;
+    }
+    return 0;
+}
+/**
+ * Checks if a user has the given flag on the given entity by checking each role the user has.
+ * @param db The DB instance
+ * @param flag The flag to check
+ * @param user The user to check
+ * @param entityId The ID of the entity to check
+ * @returns If the user has the flag on the entity
+ */
+export async function rbacCheck({ db, flag, user, entityId }) {
+    for (const role of user.roles) {
+        const rolesEntity = await db.find("role/" + role, { _id: entityId });
+        for (const entity of rolesEntity) {
+            if (entity.p & flag)
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * ABAC (Attribute-Based Access Control) check
+ * @param db The DB instance
+ * @param entityId The ID of the entity to check
+ * @param flag The flag to check
+ * @param user The user to check
+ * @param debugLog The debug log level
+ * @returns `true` if access is granted, `false` otherwise
+ */
+export async function abacCheck({ db, entityId, flag, user, debugLog }) {
+    if (!await db.issetCollection("abac/" + entityId))
+        return false;
+    const rules = await db.find("abac/" + entityId, { flag });
+    if (rules.length === 0)
+        return false;
+    for (const rule of rules) {
+        let authorized = true;
+        if (debugLog >= 1)
+            console.log(COLORS.blue + `[GW] ABAC rule: ${COLORS.yellow}${JSON.stringify(rule.condition)}${COLORS.blue} ` +
+                `-> checking...` + COLORS.reset);
+        for (const key in rule.condition) {
+            const expectedValue = rule.condition[key];
+            let actualValue;
+            if (key === "_")
+                actualValue = user;
+            else
+                actualValue = convertPath(user, key);
+            if (actualValue === undefined) {
+                authorized = false;
+                break;
+            }
+            if (!hasFieldsAdvanced(actualValue, expectedValue)) {
+                authorized = false;
+                break;
+            }
+        }
+        if (authorized) {
+            if (debugLog >= 1)
+                console.log(COLORS.green + `[GW] Access granted by this rule.` + COLORS.reset);
+            return true;
+        }
+    }
+    return false;
+}

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import GateWarden from "./warden.js";
-import UserManager from "./user.js";
-import WardenManager from "./mgr.js";
+export * from "./warden.js";
+export * from "./user.js";
+export * from "./mgr.js";
 import { AccessResult } from "./types/system.js";
-export { GateWarden, UserManager, WardenManager, AccessResult };
+export type { AccessResult };

package/dist/index.js

@@ -1,4 +1,3 @@
-import GateWarden from "./warden.js";
-import UserManager from "./user.js";
-import WardenManager from "./mgr.js";
-export { GateWarden, UserManager, WardenManager };
+export * from "./warden.js";
+export * from "./user.js";
+export * from "./mgr.js";

package/dist/log.d.ts

@@ -1,3 +1,4 @@
+import Id from "@wxn0brp/db-core/types/Id";
 export declare const COLORS: {
     reset: string;
     green: string;
@@ -5,3 +6,4 @@ export declare const COLORS: {
     red: string;
     blue: string;
 };
+export declare function logAccess(userId: Id, entityId: Id, via: string, debugLog: number): void;

package/dist/log.js

@@ -5,3 +5,9 @@ export const COLORS = {
     red: "\x1b[31m",
     blue: "\x1b[34m",
 };
+export function logAccess(userId, entityId, via, debugLog) {
+    if (debugLog < 1)
+        return;
+    console.log(`${COLORS.green}[GW] Access granted to ${COLORS.yellow}${entityId}${COLORS.green} via ` +
+        `${COLORS.yellow}${via}${COLORS.green} by ${COLORS.yellow}${userId}${COLORS.reset}`);
+}

package/dist/mgr.d.ts

@@ -1,10 +1,10 @@
 import { Id, ValtheraCompatible } from "@wxn0brp/db-core";
 import { ABACRule, ACLRule, Role, RoleEntity } from "./types/system.js";
-declare class WardenManager {
+export declare class WardenManager {
     private db;
     constructor(db: ValtheraCompatible);
     changeRoleNameToId(name: string): Promise<Id>;
-    addRole(role: Role): Promise<Role>;
+    addRole(role: Role | Omit<Role, "_id">): Promise<Role>;
     addACLRule(entityId: string, p: number, uid?: Id): Promise<ACLRule>;
     addRBACRule(role_id: string, entity_id: string, p: number): Promise<RoleEntity>;
     addABACRule(entity_id: string, flag: number, condition: ABACRule["condition"]): Promise<ABACRule>;
@@ -13,4 +13,3 @@ declare class WardenManager {
     removeRBACRule(roleId: string, entityId: string): Promise<boolean>;
     removeABACRule(entityId: string, flag: number): Promise<boolean>;
 }
-export default WardenManager;

package/dist/mgr.js

@@ -1,4 +1,4 @@
-class WardenManager {
+export class WardenManager {
     db;
     constructor(db) {
         this.db = db;
@@ -37,4 +37,3 @@ class WardenManager {
         return await this.db.removeOne("abac/" + entityId, { flag });
     }
 }
-export default WardenManager;

package/dist/test/abac.test.d.ts

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

package/dist/test/abac.test.js

@@ -0,0 +1,148 @@
+import { createMemoryValthera } from "@wxn0brp/db-core";
+import { describe, expect, it } from "bun:test";
+import { abacCheck } from "../check.js";
+describe("Access Control Checks", () => {
+    describe("abacCheck", () => {
+        it("should return false when entity has no ABAC collection", async () => {
+            const db = createMemoryValthera({});
+            const user = { _id: "user1", roles: [], attrib: { department: "engineering" } };
+            const result = await abacCheck({
+                db,
+                entityId: "entity1",
+                flag: 1,
+                user,
+                debugLog: 0
+            });
+            expect(result).toBe(false);
+        });
+        it("should return true when user attributes match ABAC rule", async () => {
+            const abacRules = [
+                {
+                    flag: 1,
+                    condition: {
+                        attrib: {
+                            department: "engineering"
+                        }
+                    }
+                }
+            ];
+            const db = createMemoryValthera({
+                "abac/entity1": abacRules
+            });
+            const user = { _id: "user1", roles: [], attrib: { department: "engineering" } };
+            const result = await abacCheck({
+                db,
+                entityId: "entity1",
+                flag: 1,
+                user,
+                debugLog: 0
+            });
+            expect(result).toBe(true);
+        });
+        it("should return false when user attributes don't match ABAC rule", async () => {
+            const abacRules = [
+                {
+                    flag: 1,
+                    condition: {
+                        attrib: {
+                            department: "engineering"
+                        }
+                    }
+                }
+            ];
+            const db = createMemoryValthera({
+                "abac/entity1": abacRules
+            });
+            const user = { _id: "user1", roles: [], attrib: { department: "marketing" } };
+            const result = await abacCheck({
+                db,
+                entityId: "entity1",
+                flag: 1,
+                user,
+                debugLog: 0
+            });
+            expect(result).toBe(false);
+        });
+        it("should handle nested attribute paths correctly", async () => {
+            const abacRules = [
+                {
+                    flag: 1,
+                    condition: {
+                        "attrib.profile": {
+                            level: 5
+                        }
+                    }
+                }
+            ];
+            const db = createMemoryValthera({
+                "abac/entity1": abacRules
+            });
+            const user = {
+                _id: "user1",
+                roles: [],
+                attrib: {
+                    profile: {
+                        level: 5,
+                        name: "test"
+                    }
+                }
+            };
+            const result = await abacCheck({
+                db,
+                entityId: "entity1",
+                flag: 1,
+                user,
+                debugLog: 0
+            });
+            expect(result).toBe(true);
+        });
+        it("should return false when user attributes are undefined", async () => {
+            const abacRules = [
+                {
+                    flag: 1,
+                    condition: {
+                        attrib: {
+                            department: "engineering"
+                        }
+                    }
+                }
+            ];
+            const db = createMemoryValthera({
+                "abac/entity1": abacRules
+            });
+            const user = { _id: "user1", roles: [], attrib: {} }; // No department
+            const result = await abacCheck({
+                db,
+                entityId: "entity1",
+                flag: 1,
+                user,
+                debugLog: 0
+            });
+            expect(result).toBe(false);
+        });
+        it("should return true when checking user root properties with _", async () => {
+            const abacRules = [
+                {
+                    flag: 1,
+                    condition: {
+                        _: {
+                            _id: "user1"
+                        }
+                    }
+                }
+            ];
+            const db = createMemoryValthera({
+                "abac/entity1": abacRules
+            });
+            const user = { _id: "user1", roles: [], attrib: {} };
+            const result = await abacCheck({
+                db,
+                entityId: "entity1",
+                flag: 1,
+                user,
+                debugLog: 0
+            });
+            expect(result).toBe(true);
+        });
+    });
+});

package/dist/test/act.test.d.ts

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

package/dist/test/act.test.js

@@ -0,0 +1,85 @@
+import { createMemoryValthera } from "@wxn0brp/db-core";
+import { describe, expect, it } from "bun:test";
+import { aclCheck } from "../check.js";
+describe("Access Control Checks", () => {
+    describe("aclCheck", () => {
+        it("should return -1 when entity has no ACL collection", async () => {
+            const db = createMemoryValthera({});
+            const user = { _id: "user1", roles: [], attrib: {} };
+            const result = await aclCheck({
+                db,
+                entityId: "entity1",
+                flag: 1,
+                user
+            });
+            expect(result).toBe(-1);
+        });
+        it("should return 1 when user has the specific flag in ACL", async () => {
+            const aclRules = [
+                { uid: "user1", p: 5 } // User has flags 1 and 4 (1 | 4 = 5)
+            ];
+            const db = createMemoryValthera({
+                "acl/entity1": aclRules
+            });
+            const user = { _id: "user1", roles: [], attrib: {} };
+            // Check for flag 1 (should be granted)
+            const result = await aclCheck({
+                db,
+                entityId: "entity1",
+                flag: 1,
+                user
+            });
+            expect(result).toBe(1);
+        });
+        it("should return 0 when user does not have the flag in ACL", async () => {
+            const aclRules = [
+                { uid: "user1", p: 4 } // User has only flag 4
+            ];
+            const db = createMemoryValthera({
+                "acl/entity1": aclRules
+            });
+            const user = { _id: "user1", roles: [], attrib: {} };
+            // Check for flag 1 (should not be granted)
+            const result = await aclCheck({
+                db,
+                entityId: "entity1",
+                flag: 1,
+                user
+            });
+            expect(result).toBe(0);
+        });
+        it("should return 1 when there is a public rule with the flag", async () => {
+            const aclRules = [
+                { p: 3 } // Public rule with flags 1 and 2
+            ];
+            const db = createMemoryValthera({
+                "acl/entity1": aclRules
+            });
+            const user = { _id: "user1", roles: [], attrib: {} };
+            // Check for flag 1 (should be granted via public rule)
+            const result = await aclCheck({
+                db,
+                entityId: "entity1",
+                flag: 1,
+                user
+            });
+            expect(result).toBe(1);
+        });
+        it("should return -1 when no rules match the user or public access", async () => {
+            const aclRules = [
+                { uid: "user2", p: 1 } // Different user has the flag
+            ];
+            const db = createMemoryValthera({
+                "acl/entity1": aclRules
+            });
+            const user = { _id: "user1", roles: [], attrib: {} };
+            const result = await aclCheck({
+                db,
+                entityId: "entity1",
+                flag: 1,
+                user
+            });
+            expect(result).toBe(-1);
+        });
+    });
+});

package/dist/test/rbac.test.d.ts

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

package/dist/test/rbac.test.js

@@ -0,0 +1,69 @@
+import { createMemoryValthera } from "@wxn0brp/db-core";
+import { describe, expect, it } from "bun:test";
+import { rbacCheck } from "../check.js";
+describe("Access Control Checks", () => {
+    describe("rbacCheck", () => {
+        it("should return true when user has role with the required flag", async () => {
+            const rolesData = [
+                { _id: "resource1", p: 5 } // Flags 1 and 4
+            ];
+            const db = createMemoryValthera({
+                "role/admin": rolesData
+            });
+            const user = { _id: "user1", roles: ["admin"], attrib: {} };
+            // Check for flag 1 (should be granted by admin role)
+            const result = await rbacCheck({
+                db,
+                entityId: "resource1",
+                flag: 1,
+                user
+            });
+            expect(result).toBe(true);
+        });
+        it("should return false when user has role without the required flag", async () => {
+            const rolesData = [
+                { _id: "resource1", p: 4 } // Only flag 4
+            ];
+            const db = createMemoryValthera({
+                "role/admin": rolesData
+            });
+            const user = { _id: "user1", roles: ["admin"], attrib: {} };
+            // Check for flag 1 (should not be granted)
+            const result = await rbacCheck({
+                db,
+                entityId: "resource1",
+                flag: 1,
+                user
+            });
+            expect(result).toBe(false);
+        });
+        it("should return false when user has no matching role-entity permissions", async () => {
+            const rolesData = [
+                { _id: "resource2", p: 1 } // Different resource
+            ];
+            const db = createMemoryValthera({
+                "role/admin": rolesData
+            });
+            const user = { _id: "user1", roles: ["admin"], attrib: {} };
+            // Check for resource1 when only resource2 permissions exist
+            const result = await rbacCheck({
+                db,
+                entityId: "resource1",
+                flag: 1,
+                user
+            });
+            expect(result).toBe(false);
+        });
+        it("should return false when user has no roles", async () => {
+            const db = createMemoryValthera({});
+            const user = { _id: "user1", roles: [], attrib: {} };
+            const result = await rbacCheck({
+                db,
+                entityId: "resource1",
+                flag: 1,
+                user
+            });
+            expect(result).toBe(false);
+        });
+    });
+});

package/dist/types/check.d.ts

@@ -0,0 +1,10 @@
+import { ValtheraCompatible } from "@wxn0brp/db-core";
+import Id from "@wxn0brp/db-core/types/Id";
+import { User } from "./system.js";
+export interface CheckParams {
+    db: ValtheraCompatible;
+    entityId: Id;
+    flag: number;
+    user: User;
+    debugLog?: number;
+}

package/dist/types/check.js

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

package/dist/user.d.ts

@@ -1,6 +1,6 @@
 import { Id, ValtheraCompatible } from "@wxn0brp/db-core";
 import { User } from "./types/system.js";
-declare class UserManager<A = any> {
+export declare class UserManager<A = any> {
     private db;
     constructor(db: ValtheraCompatible);
     /**
@@ -48,4 +48,3 @@ declare class UserManager<A = any> {
      */
     updateAttributes(user_id: Id, attributes: Partial<A>): Promise<void>;
 }
-export default UserManager;

package/dist/user.js

@@ -1,4 +1,4 @@
-class UserManager {
+export class UserManager {
     db;
     constructor(db) {
         this.db = db;
@@ -84,4 +84,3 @@ class UserManager {
         await this.db.update("users", { _id: user_id }, user);
     }
 }
-export default UserManager;

package/dist/utils.d.ts

@@ -0,0 +1 @@
+export declare function convertPath(user: any, path: string): any;

package/dist/utils.js

@@ -0,0 +1,10 @@
+export function convertPath(user, path) {
+    const keys = path.split(".");
+    let data = user;
+    for (const key of keys) {
+        data = data?.[key];
+        if (data === undefined)
+            return undefined;
+    }
+    return data;
+}

package/dist/warden.d.ts

@@ -1,9 +1,10 @@
-import { ValtheraCompatible } from "@wxn0brp/db-core";
-import { AccessResult } from "./types/system.js";
-declare class GateWarden<A = any> {
-    private db;
+import { Id, ValtheraCompatible } from "@wxn0brp/db-core";
+import { AccessResult, User } from "./types/system.js";
+export declare function fetchUser(db: ValtheraCompatible, userId: Id): Promise<User>;
+export declare function matchPermission(db: ValtheraCompatible, entityId: Id, flag: number, user: User, debugLog: number): Promise<AccessResult>;
+export declare class GateWarden {
+    db: ValtheraCompatible;
     debugLog: number;
     constructor(db: ValtheraCompatible, debugLog?: number);
     hasAccess(userId: string, entityId: string, flag: number): Promise<AccessResult>;
 }
-export default GateWarden;

package/dist/warden.js

@@ -1,122 +1,12 @@
-import { COLORS } from "./log.js";
-import hasFieldsAdvanced from "@wxn0brp/db-core/utils/hasFieldsAdvanced";
-function logAccess(userId, entityId, via, debugLog) {
-    if (debugLog < 1)
-        return;
-    console.log(`${COLORS.green}[GW] Access granted to ${COLORS.yellow}${entityId}${COLORS.green} via ` +
-        `${COLORS.yellow}${via}${COLORS.green} by ${COLORS.yellow}${userId}${COLORS.reset}`);
-}
-async function fetchUser(db, userId) {
+import { abacCheck, aclCheck, rbacCheck } from "./check.js";
+import { COLORS, logAccess } from "./log.js";
+export async function fetchUser(db, userId) {
     const user = await db.findOne("users", { _id: userId });
     if (!user)
         throw new Error("User not found");
     return user;
 }
-/**
- * Checks if a user has the given flag on the given entity by checking the entity's ACL.
- * @param db The DB instance
- * @param flag The flag to check
- * @param user The user to check
- * @param entityId The ID of the entity to check
- * @returns If the user has the flag on the entity:
- *   - 1 if the user has the flag
- *   - 0 if the user does not have the flag
- *   - -1 if the entity does not have an ACL
- */
-async function aclCheck({ db, entityId, flag, user }) {
-    if (!await db.issetCollection("acl/" + entityId))
-        return -1;
-    const rules = await db.find("acl/" + entityId, {
-        $or: [
-            { uid: user._id },
-            {
-                $not: {
-                    $exists: { "uid": true }
-                }
-            }
-        ]
-    });
-    if (rules.length === 0)
-        return -1;
-    for (const rule of rules) {
-        if (rule.p & flag)
-            return 1;
-    }
-    return 0;
-}
-/**
- * Checks if a user has the given flag on the given entity by checking each role the user has.
- * @param db The DB instance
- * @param flag The flag to check
- * @param user The user to check
- * @param entityId The ID of the entity to check
- * @returns If the user has the flag on the entity
- */
-async function rbacCheck({ db, flag, user, entityId }) {
-    for (const role of user.roles) {
-        const rolesEntity = await db.find("role/" + role, { _id: entityId });
-        for (const entity of rolesEntity) {
-            if (entity.p & flag)
-                return true;
-        }
-    }
-    return false;
-}
-function convertPath(user, path) {
-    const keys = path.split(".");
-    let data = user;
-    for (const key of keys) {
-        data = data?.[key];
-        if (data === undefined)
-            return undefined;
-    }
-    return data;
-}
-/**
- * ABAC (Attribute-Based Access Control) check
- * @param db The DB instance
- * @param entityId The ID of the entity to check
- * @param flag The flag to check
- * @param user The user to check
- * @param debugLog The debug log level
- * @returns `true` if access is granted, `false` otherwise
- */
-async function abacCheck({ db, entityId, flag, user, debugLog }) {
-    if (!await db.issetCollection("abac/" + entityId))
-        return false;
-    const rules = await db.find("abac/" + entityId, { flag });
-    if (rules.length === 0)
-        return false;
-    for (const rule of rules) {
-        let authorized = true;
-        if (debugLog >= 1)
-            console.log(COLORS.blue + `[GW] ABAC rule: ${COLORS.yellow}${JSON.stringify(rule.condition)}${COLORS.blue} ` +
-                `-> checking...` + COLORS.reset);
-        for (const key in rule.condition) {
-            const expectedValue = rule.condition[key];
-            let actualValue;
-            if (key === "_")
-                actualValue = user;
-            else
-                actualValue = convertPath(user, key);
-            if (actualValue === undefined) {
-                authorized = false;
-                break;
-            }
-            if (!hasFieldsAdvanced(actualValue, expectedValue)) {
-                authorized = false;
-                break;
-            }
-        }
-        if (authorized) {
-            if (debugLog >= 1)
-                console.log(COLORS.green + `[GW] Access granted by this rule.` + COLORS.reset);
-            return true;
-        }
-    }
-    return false;
-}
-async function matchPermission(db, entityId, flag, user, debugLog) {
+export async function matchPermission(db, entityId, flag, user, debugLog) {
     const checks = [
         { name: "ACL", method: aclCheck },
         { name: "RBAC", method: rbacCheck },
@@ -136,7 +26,7 @@ async function matchPermission(db, entityId, flag, user, debugLog) {
     }
     return { granted: false, via: null };
 }
-class GateWarden {
+export class GateWarden {
     db;
     debugLog;
     constructor(db, debugLog = 0) {
@@ -171,4 +61,3 @@ class GateWarden {
         };
     }
 }
-export default GateWarden;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/gate-warden",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "wxn0brP",
@@ -13,13 +13,14 @@
   },
   "homepage": "https://github.com/wxn0brP/gate-warden",
   "devDependencies": {
-    "@types/node": "^24.1.0",
-    "@wxn0brp/db-core": "^0.1.2",
-    "tsc-alias": "^1.8.16",
-    "typescript": "^5.8.3"
+    "@types/bun": "*",
+    "@types/node": "*",
+    "@wxn0brp/db-core": "^0.2.7",
+    "tsc-alias": "*",
+    "typescript": "*"
   },
   "peerDependencies": {
-    "@wxn0brp/db-core": ">=0.1.2"
+    "@wxn0brp/db-core": ">=0.2.7"
   },
   "files": [
     "dist"
@@ -27,12 +28,13 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
+      "default": "./dist/index.js",
       "import": "./dist/index.js"
     },
     "./*": {
-      "types": "./dist/*",
-      "import": "./dist/*"
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js",
+      "import": "./dist/*.js"
     }
-  },
-  "dependencies": {}
-}
+  }
+}