@zakyyudha/node-authzkit 1.0.0

package/tests/MongoAuthzkitStore.test.ts

@@ -0,0 +1,204 @@
+import { Authzkit } from '../src/classes/Authzkit';
+import { Authorizable } from '../src/interfaces/Authorizable';
+import { MongoConnection } from '../src/drivers/mongodb/mongo-connection';
+import { MongoAuthzkitStore } from '../src/stores/MongoAuthzkitStore';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import { MongoClient } from 'mongodb';
+import { IAuthzkitConfig } from '../src/interfaces/IAuthzkitConfig';
+
+// Increase Jest timeout for MongoDB operations
+jest.setTimeout(30000); // 30 seconds
+
+describe('MongoAuthzkitStore', () => {
+  let mongod: MongoMemoryServer;
+  let mongoClient: MongoClient;
+  let mongoConnection: MongoConnection;
+  let mongoAuthzkitStore: MongoAuthzkitStore;
+  let authzkit: Authzkit;
+  let user: Authorizable;
+
+  beforeAll(async () => {
+    mongod = await MongoMemoryServer.create();
+    const uri = mongod.getUri();
+    const dbName = 'authzkit_test_db';
+
+    // Connect MongoClient and pass it to MongoConnection
+    mongoClient = new MongoClient(uri);
+    await mongoClient.connect();
+
+    const config: IAuthzkitConfig = {
+      connection: {
+        type: 'mongodb',
+        uri: uri,
+        database: dbName,
+      },
+    };
+
+    mongoConnection = MongoConnection.getInstance(config, mongoClient);
+    await mongoConnection.connect(); // This should now just set the db instance
+
+    // Ensure the database is clean before running tests
+    await mongoConnection.getDb().dropDatabase();
+  });
+
+  beforeEach(async () => {
+    // Re-initialize store and authzkit for each test to ensure isolation
+    mongoAuthzkitStore = new MongoAuthzkitStore(mongoConnection);
+    Authzkit.getInstance(mongoAuthzkitStore);
+    authzkit = Authzkit.getInstance();
+    await authzkit.reset(); // Clear all data for current test
+
+    // Define some permissions and roles
+    await authzkit.definePermission('create_post');
+    await authzkit.definePermission('edit_post');
+    await authzkit.definePermission('delete_post');
+    await authzkit.definePermission('view_dashboard');
+
+    await authzkit.defineRole('admin', [
+      'create_post',
+      'edit_post',
+      'delete_post',
+      'view_dashboard',
+    ]);
+    await authzkit.defineRole('editor', ['create_post', 'edit_post']);
+    await authzkit.defineRole('viewer', ['view_dashboard']);
+
+    user = { id: 'user1', roles: [], permissions: [] }; // Changed to string for consistency with MongoDB IDs
+  });
+
+  afterAll(async () => {
+    await mongoConnection.getDb().dropDatabase(); // Clean up database after all tests
+    await mongoClient.close(); // Close the MongoClient connection
+    await mongod.stop(); // Stop the in-memory MongoDB server
+  });
+
+  // --- Permission Definition Tests ---
+  test('should define a permission', async () => {
+    const perm = await authzkit.definePermission('new_mongo_permission');
+    expect(perm).toEqual({ name: 'new_mongo_permission', guard_name: undefined });
+    await expect(authzkit.definePermission('new_mongo_permission')).rejects.toThrow(
+      "Permission 'new_mongo_permission' already exists."
+    );
+  });
+
+  // --- Role Definition Tests ---
+  test('should define a role with permissions', async () => {
+    const role = await authzkit.defineRole('mongo_moderator', ['edit_post']);
+    expect(role).toEqual({
+      name: 'mongo_moderator',
+      permissions: ['edit_post'],
+      guard_name: undefined,
+    });
+    await expect(authzkit.defineRole('admin')).rejects.toThrow("Role 'admin' already exists.");
+  });
+
+  test('should throw error if role is defined with non-existent permission', async () => {
+    await expect(
+      authzkit.defineRole('bad_mongo_role', ['non_existent_mongo_permission'])
+    ).rejects.toThrow(
+      "Permission 'non_existent_mongo_permission' not found when defining role 'bad_mongo_role'."
+    );
+  });
+
+  // --- Assignment Tests ---
+  test('should assign a role to a user', async () => {
+    await authzkit.assignRole(user, 'editor');
+    expect(await authzkit.hasRole(user, 'editor')).toBe(true);
+    expect(await authzkit.hasRole(user, 'admin')).toBe(false);
+  });
+
+  test('should assign a direct permission to a user', async () => {
+    await authzkit.assignPermission(user, 'create_post');
+    expect(await authzkit.hasPermission(user, 'create_post')).toBe(true);
+    expect(await authzkit.hasPermission(user, 'edit_post')).toBe(false);
+  });
+
+  test('should throw error if assigning non-existent role', async () => {
+    await expect(authzkit.assignRole(user, 'non_existent_mongo_role')).rejects.toThrow(
+      "Role 'non_existent_mongo_role' not found."
+    );
+  });
+
+  test('should throw error if assigning non-existent permission', async () => {
+    await expect(authzkit.assignPermission(user, 'non_existent_mongo_permission')).rejects.toThrow(
+      "Permission 'non_existent_mongo_permission' not found."
+    );
+  });
+
+  // --- Revocation Tests ---
+  test('should revoke a role from a user', async () => {
+    await authzkit.assignRole(user, 'editor');
+    expect(await authzkit.hasRole(user, 'editor')).toBe(true);
+    await authzkit.revokeRole(user, 'editor');
+    expect(await authzkit.hasRole(user, 'editor')).toBe(false);
+  });
+
+  test('should revoke a direct permission from a user', async () => {
+    await authzkit.assignPermission(user, 'create_post');
+    expect(await authzkit.hasPermission(user, 'create_post')).toBe(true);
+    await authzkit.revokePermission(user, 'create_post');
+    expect(await authzkit.hasPermission(user, 'create_post')).toBe(false);
+  });
+
+  // --- Has Role/Permission Tests ---
+  test('user with role should have role', async () => {
+    await authzkit.assignRole(user, 'admin');
+    expect(await authzkit.hasRole(user, 'admin')).toBe(true);
+  });
+
+  test('user without role should not have role', async () => {
+    expect(await authzkit.hasRole(user, 'admin')).toBe(false);
+  });
+
+  test('user with direct permission should have permission', async () => {
+    await authzkit.assignPermission(user, 'edit_post');
+    expect(await authzkit.hasPermission(user, 'edit_post')).toBe(true);
+  });
+
+  test('user with role having permission should have permission', async () => {
+    await authzkit.assignRole(user, 'editor'); // editor has create_post, edit_post
+    expect(await authzkit.hasPermission(user, 'create_post')).toBe(true);
+    expect(await authzkit.hasPermission(user, 'edit_post')).toBe(true);
+    expect(await authzkit.hasPermission(user, 'delete_post')).toBe(false);
+  });
+
+  test('user with admin role should have all admin permissions', async () => {
+    await authzkit.assignRole(user, 'admin');
+    expect(await authzkit.hasPermission(user, 'create_post')).toBe(true);
+    expect(await authzkit.hasPermission(user, 'edit_post')).toBe(true);
+    expect(await authzkit.hasPermission(user, 'delete_post')).toBe(true);
+    expect(await authzkit.hasPermission(user, 'view_dashboard')).toBe(true);
+  });
+
+  test('user with no permissions/roles should not have any permissions', async () => {
+    expect(await authzkit.hasPermission(user, 'create_post')).toBe(false);
+    expect(await authzkit.hasRole(user, 'admin')).toBe(false);
+  });
+
+  test('roleHasPermission should work correctly', async () => {
+    expect(await authzkit.roleHasPermission('admin', 'create_post')).toBe(true);
+    expect(await authzkit.roleHasPermission('editor', 'delete_post')).toBe(false);
+    expect(await authzkit.roleHasPermission('viewer', 'view_dashboard')).toBe(true);
+    expect(await authzkit.roleHasPermission('non_existent_role', 'some_permission')).toBe(false);
+  });
+
+  // --- Reset Tests ---
+  test('reset should clear all permissions, roles, and assignments', async () => {
+    await authzkit.definePermission('test_mongo_perm');
+    await authzkit.defineRole('test_mongo_role', ['test_mongo_perm']);
+    await authzkit.assignRole(user, 'test_mongo_role');
+    await authzkit.assignPermission(user, 'test_mongo_perm');
+
+    await authzkit.reset();
+
+    // After reset, defining again should not throw an error (as they were cleared)
+    await expect(authzkit.definePermission('test_mongo_perm')).resolves.not.toThrow();
+    await expect(
+      authzkit.defineRole('test_mongo_role', ['test_mongo_perm'])
+    ).resolves.not.toThrow();
+
+    // User should no longer have the role/permission
+    expect(await authzkit.hasRole(user, 'test_mongo_role')).toBe(false);
+    expect(await authzkit.hasPermission(user, 'test_mongo_perm')).toBe(false);
+  });
+});

package/tests/MongoAuthzkitStoreCustom.test.ts

@@ -0,0 +1,75 @@
+import { Authzkit } from '../src/classes/Authzkit';
+import { MongoConnection } from '../src/drivers/mongodb/mongo-connection';
+import { MongoAuthzkitStore } from '../src/stores/MongoAuthzkitStore';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import { MongoClient } from 'mongodb';
+import { IAuthzkitConfig } from '../src/interfaces/IAuthzkitConfig';
+
+// Increase Jest timeout for MongoDB operations
+jest.setTimeout(30000); // 30 seconds
+
+describe('MongoAuthzkitStore (Custom Collections)', () => {
+  let mongod: MongoMemoryServer;
+  let mongoClient: MongoClient;
+  let mongoConnection: MongoConnection;
+  let mongoAuthzkitStore: MongoAuthzkitStore;
+  let authzkit: Authzkit;
+
+  beforeAll(async () => {
+    mongod = await MongoMemoryServer.create();
+    const uri = mongod.getUri();
+    const dbName = 'authzkit_test_custom_db';
+
+    // Connect MongoClient and pass it to MongoConnection
+    mongoClient = new MongoClient(uri);
+    await mongoClient.connect();
+
+    const config: IAuthzkitConfig = {
+      connection: {
+        type: 'mongodb',
+        uri: uri,
+        database: dbName,
+      },
+      models: {
+        users: 'custom_users',
+        roles: 'custom_roles',
+        permissions: 'custom_permissions',
+        user_roles: 'custom_user_roles',
+        user_permissions: 'custom_user_permissions',
+      },
+    };
+
+    mongoConnection = MongoConnection.getInstance(config, mongoClient);
+    await mongoConnection.connect(); // This should now just set the db instance
+
+    // Ensure the database is clean before running tests
+    await mongoConnection.getDb().dropDatabase();
+  });
+
+  beforeEach(async () => {
+    // Re-initialize store and authzkit for each test to ensure isolation
+    mongoAuthzkitStore = new MongoAuthzkitStore(mongoConnection);
+    Authzkit.getInstance(mongoAuthzkitStore);
+    authzkit = Authzkit.getInstance();
+    await authzkit.reset(); // Clear all data for current test
+
+    await authzkit.definePermission('custom_perm');
+  });
+
+  afterAll(async () => {
+    await mongoConnection.getDb().dropDatabase(); // Clean up database after all tests
+    await mongoClient.close(); // Close the MongoClient connection
+    await mongod.stop(); // Stop the in-memory MongoDB server
+  });
+
+  test('should store data in custom collections', async () => {
+    const db = mongoConnection.getDb();
+    // Verify data is in 'custom_permissions' collection
+    const count = await db.collection('custom_permissions').countDocuments({ name: 'custom_perm' });
+    expect(count).toBe(1);
+
+    // Verify default collection is empty
+    const defaultCount = await db.collection('permissions').countDocuments({ name: 'custom_perm' });
+    expect(defaultCount).toBe(0);
+  });
+});

package/tests/PgAuthzkitStore.test.ts

@@ -0,0 +1,207 @@
+import { Authzkit } from '../src/classes/Authzkit';
+import { Authorizable } from '../src/interfaces/Authorizable';
+import { PgConnection } from '../src/drivers/postgres/pg-connection';
+import { newDb } from 'pg-mem';
+import { PgAuthzkitStore } from '../src/stores/PgAuthzkitStore';
+import { IAuthzkitConfig } from '../src/interfaces/IAuthzkitConfig';
+
+// Increase Jest timeout for PostgreSQL operations
+jest.setTimeout(30000); // 30 seconds
+
+describe('PgAuthzkitStore', () => {
+  let pgMemDb: any; // Use any because IMemoryDb doesn't have clone method directly
+  let pgConnection: PgConnection;
+  let pgAuthzkitStore: PgAuthzkitStore;
+  let authzkit: Authzkit;
+  let user: Authorizable;
+
+  // No actual connection string needed for in-memory db
+  const CONNECTION_STRING = 'in-memory-db';
+
+  beforeAll(async () => {
+    // pg-mem's newDb() method creates a fresh, isolated database instance.
+    // We create one for the whole test suite as pg-mem can be reset efficiently.
+    pgMemDb = newDb();
+
+    const config: IAuthzkitConfig = {
+      connection: {
+        type: 'postgres',
+        uri: CONNECTION_STRING,
+      },
+    };
+
+    pgConnection = PgConnection.getInstance(config, pgMemDb);
+    // No need to call pgConnection.connect() for pg-mem, as it's mocked
+    await pgConnection.initSchema(); // Initialize schema for tests
+  });
+
+  beforeEach(async () => {
+    // For pg-mem, pgMemDb.public.query('TRUNCATE ...') is the way to reset data.
+    // This is handled by authzkit.reset() which calls pgAuthzkitStore.reset().
+    // We need to re-initialize PgConnection for each test to ensure its internal state is clean.
+
+    const config: IAuthzkitConfig = {
+      connection: {
+        type: 'postgres',
+        uri: CONNECTION_STRING + Math.random(),
+      },
+    };
+
+    pgConnection = PgConnection.getInstance(config, pgMemDb); // Unique connectionString for singleton instance tracking
+    pgAuthzkitStore = new PgAuthzkitStore(pgConnection);
+    Authzkit.getInstance(pgAuthzkitStore); // Initialize Authzkit with the Pg store
+    authzkit = Authzkit.getInstance(); // Get the instance, ensure it's the one we just set
+    await authzkit.reset(); // Clear all data for current test using the clean schema
+
+    // Define some permissions and roles
+    await authzkit.definePermission('create_pg_post');
+    await authzkit.definePermission('edit_pg_post');
+    await authzkit.definePermission('delete_pg_post');
+    await authzkit.definePermission('view_pg_dashboard');
+
+    await authzkit.defineRole('pg_admin', [
+      'create_pg_post',
+      'edit_pg_post',
+      'delete_pg_post',
+      'view_pg_dashboard',
+    ]);
+    await authzkit.defineRole('pg_editor', ['create_pg_post', 'edit_pg_post']);
+    await authzkit.defineRole('pg_viewer', ['view_pg_dashboard']);
+
+    user = { id: 'pg_user1', roles: [], permissions: [] }; // Using string ID
+  });
+
+  afterAll(async () => {
+    // No explicit disconnect needed for pg-mem
+  });
+
+  // --- Permission Definition Tests ---
+  test('should define a permission', async () => {
+    const perm = await authzkit.definePermission('new_pg_permission');
+    expect(perm).toEqual({ name: 'new_pg_permission', guard_name: undefined });
+    await expect(authzkit.definePermission('new_pg_permission')).rejects.toThrow(
+      /Permission 'new_pg_permission' already exists./
+    );
+  });
+
+  // --- Role Definition Tests ---
+  test('should define a role with permissions', async () => {
+    const role = await authzkit.defineRole('pg_moderator', ['edit_pg_post']);
+    expect(role).toEqual({
+      name: 'pg_moderator',
+      permissions: ['edit_pg_post'],
+      guard_name: undefined,
+    });
+    await expect(authzkit.defineRole('pg_admin')).rejects.toThrow(
+      /Role 'pg_admin' already exists./
+    );
+  });
+
+  test('should throw error if role is defined with non-existent permission', async () => {
+    await expect(
+      authzkit.defineRole('bad_pg_role', ['non_existent_pg_permission'])
+    ).rejects.toThrow(
+      /Permission 'non_existent_pg_permission' not found when defining role 'bad_pg_role'./
+    );
+  });
+
+  // --- Assignment Tests ---
+  test('should assign a role to a user', async () => {
+    await authzkit.assignRole(user, 'pg_editor');
+    expect(await authzkit.hasRole(user, 'pg_editor')).toBe(true);
+    expect(await authzkit.hasRole(user, 'pg_admin')).toBe(false);
+  });
+
+  test('should assign a direct permission to a user', async () => {
+    await authzkit.assignPermission(user, 'create_pg_post');
+    expect(await authzkit.hasPermission(user, 'create_pg_post')).toBe(true);
+    expect(await authzkit.hasPermission(user, 'edit_pg_post')).toBe(false);
+  });
+
+  test('should throw error if assigning non-existent role', async () => {
+    await expect(authzkit.assignRole(user, 'non_existent_pg_role')).rejects.toThrow(
+      /Role 'non_existent_pg_role' not found./
+    );
+  });
+
+  test('should throw error if assigning non-existent permission', async () => {
+    await expect(authzkit.assignPermission(user, 'non_existent_pg_permission')).rejects.toThrow(
+      /Permission 'non_existent_pg_permission' not found./
+    );
+  });
+
+  // --- Revocation Tests ---
+  test('should revoke a role from a user', async () => {
+    await authzkit.assignRole(user, 'pg_editor');
+    expect(await authzkit.hasRole(user, 'pg_editor')).toBe(true);
+    await authzkit.revokeRole(user, 'pg_editor');
+    expect(await authzkit.hasRole(user, 'pg_editor')).toBe(false);
+  });
+
+  test('should revoke a direct permission from a user', async () => {
+    await authzkit.assignPermission(user, 'create_pg_post');
+    expect(await authzkit.hasPermission(user, 'create_pg_post')).toBe(true);
+    await authzkit.revokePermission(user, 'create_pg_post');
+    expect(await authzkit.hasPermission(user, 'create_pg_post')).toBe(false);
+  });
+
+  // --- Has Role/Permission Tests ---
+  test('user with role should have role', async () => {
+    await authzkit.assignRole(user, 'pg_admin');
+    expect(await authzkit.hasRole(user, 'pg_admin')).toBe(true);
+  });
+
+  test('user without role should not have role', async () => {
+    expect(await authzkit.hasRole(user, 'pg_admin')).toBe(false);
+  });
+
+  test('user with direct permission should have permission', async () => {
+    await authzkit.assignPermission(user, 'edit_pg_post');
+    expect(await authzkit.hasPermission(user, 'edit_pg_post')).toBe(true);
+  });
+
+  test('user with role having permission should have permission', async () => {
+    await authzkit.assignRole(user, 'pg_editor'); // pg_editor has create_pg_post, edit_pg_post
+    expect(await authzkit.hasPermission(user, 'create_pg_post')).toBe(true);
+    expect(await authzkit.hasPermission(user, 'edit_pg_post')).toBe(true);
+    expect(await authzkit.hasPermission(user, 'delete_pg_post')).toBe(false);
+  });
+
+  test('user with admin role should have all admin permissions', async () => {
+    await authzkit.assignRole(user, 'pg_admin');
+    expect(await authzkit.hasPermission(user, 'create_pg_post')).toBe(true);
+    expect(await authzkit.hasPermission(user, 'edit_pg_post')).toBe(true);
+    expect(await authzkit.hasPermission(user, 'delete_pg_post')).toBe(true);
+    expect(await authzkit.hasPermission(user, 'view_pg_dashboard')).toBe(true);
+  });
+
+  test('user with no permissions/roles should not have any permissions', async () => {
+    expect(await authzkit.hasPermission(user, 'create_pg_post')).toBe(false);
+    expect(await authzkit.hasRole(user, 'pg_admin')).toBe(false);
+  });
+
+  test('roleHasPermission should work correctly', async () => {
+    expect(await authzkit.roleHasPermission('pg_admin', 'create_pg_post')).toBe(true);
+    expect(await authzkit.roleHasPermission('pg_editor', 'delete_pg_post')).toBe(false);
+    expect(await authzkit.roleHasPermission('pg_viewer', 'view_pg_dashboard')).toBe(true);
+    expect(await authzkit.roleHasPermission('non_existent_pg_role', 'some_permission')).toBe(false);
+  });
+
+  // --- Reset Tests ---
+  test('reset should clear all permissions, roles, and assignments', async () => {
+    await authzkit.definePermission('test_pg_perm');
+    await authzkit.defineRole('test_pg_role', ['test_pg_perm']);
+    await authzkit.assignRole(user, 'test_pg_role');
+    await authzkit.assignPermission(user, 'test_pg_perm');
+
+    await authzkit.reset();
+
+    // After reset, defining again should not throw an error (as they were cleared)
+    await expect(authzkit.definePermission('test_pg_perm')).resolves.not.toThrow();
+    await expect(authzkit.defineRole('test_pg_role', ['test_pg_perm'])).resolves.not.toThrow();
+
+    // User should no longer have the role/permission
+    expect(await authzkit.hasRole(user, 'test_pg_role')).toBe(false);
+    expect(await authzkit.hasPermission(user, 'test_pg_perm')).toBe(false);
+  });
+});

package/tests/PgAuthzkitStoreCustom.test.ts

@@ -0,0 +1,90 @@
+import { Authzkit } from '../src/classes/Authzkit';
+import { PgConnection } from '../src/drivers/postgres/pg-connection';
+import { newDb } from 'pg-mem';
+import { PgAuthzkitStore } from '../src/stores/PgAuthzkitStore';
+import { IAuthzkitConfig } from '../src/interfaces/IAuthzkitConfig';
+
+// Increase Jest timeout
+jest.setTimeout(30000);
+
+describe('PgAuthzkitStore (Custom Tables)', () => {
+  let pgMemDb: any;
+  let pgConnection: PgConnection;
+  let pgAuthzkitStore: PgAuthzkitStore;
+  let authzkit: Authzkit;
+
+  const CONNECTION_STRING = 'in-memory-db-custom';
+
+  beforeAll(async () => {
+    pgMemDb = newDb();
+
+    // We need to initialize schema with custom names
+    const config: IAuthzkitConfig = {
+      connection: {
+        type: 'postgres',
+        uri: CONNECTION_STRING,
+      },
+      models: {
+        users: 'custom_users',
+        roles: 'custom_roles',
+        permissions: 'custom_permissions',
+        user_roles: 'custom_user_roles',
+        user_permissions: 'custom_user_permissions',
+      },
+    };
+
+    pgConnection = PgConnection.getInstance(config, pgMemDb);
+    await pgConnection.initSchema();
+  });
+
+  beforeEach(async () => {
+    // Config matching the one used in beforeAll (for singleton to return same instance)
+    // Actually, if we pass same config object (by value/content), getInstance should return same instance.
+    // But we used random string in other test. Here we can stick to one instance since we just want to verify table names.
+    // Or we can create a new instance if we want, but we need to pass pgMemDb again.
+
+    const config: IAuthzkitConfig = {
+      connection: {
+        type: 'postgres',
+        uri: CONNECTION_STRING,
+      },
+      models: {
+        users: 'custom_users',
+        roles: 'custom_roles',
+        permissions: 'custom_permissions',
+        user_roles: 'custom_user_roles',
+        user_permissions: 'custom_user_permissions',
+      },
+    };
+
+    // We reuse the instance created in beforeAll
+    pgConnection = PgConnection.getInstance(config, pgMemDb);
+    pgAuthzkitStore = new PgAuthzkitStore(pgConnection);
+    Authzkit.getInstance(pgAuthzkitStore);
+    authzkit = Authzkit.getInstance();
+
+    // We don't call reset() here because it might truncate tables we just created?
+    // Actually reset() calls truncateTables(). PgConnection.truncateTables() uses getTableName().
+    // So if config is correct, it should truncate custom tables.
+    await authzkit.reset();
+
+    await authzkit.definePermission('custom_pg_perm');
+  });
+
+  test('should store data in custom tables', async () => {
+    // Query pg-mem directly to see if data is in custom table
+    // pg-mem exposes the DB state via pgMemDb
+
+    // we can use pgConnection.query acting as a backdoor too, but let's try to verify via "direct" SQL on the connection
+
+    const res = await pgConnection.query(
+      'SELECT count(*) FROM custom_permissions WHERE name = $1',
+      ['custom_pg_perm']
+    );
+    expect(res.rows[0].count).toBe(1);
+
+    // Verify default table does not exist or is empty
+    // In pg-mem, querying non-existent table throws error.
+    await expect(pgConnection.query('SELECT count(*) FROM permissions')).rejects.toThrow();
+  });
+});

package/tsconfig.json

@@ -0,0 +1,37 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "module": "commonjs",
+    "rootDir": ".",
+    "outDir": "./dist",
+    "baseUrl": ".",
+    "paths": {
+      "@zakyyudha/node-authzkit": [
+        "src/index.ts"
+      ]
+    },
+    "lib": [
+      "es2022",
+      "dom"
+    ],
+    "types": [
+      "jest"
+    ],
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "sourceMap": true
+  },
+  "include": [
+    "src/**/*",
+    "tests/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "node_modules",
+    "dist",
+    "src/dashboard/web"
+  ]
+}