@bool-ts/guard-sdk 1.0.2-beta.3 → 1.1.0-beta.1

package/dist/instances/client.d.ts

@@ -1,15 +1,18 @@
-import type { IClient, TClientConfigs, TClientOptions } from "../interfaces/client.interface";
+import type { IClient, TClientCredential, TClientDefinition, TClientOptions } from "../interfaces/client.interface";
 export declare class Client implements IClient {
     #private;
-    private readonly configs;
-    private readonly options?;
+    private readonly params;
     private token;
     /**
      * Initialize BoolGuard client instance
      * @param configs
      * @param options
      */
-    constructor(configs: TClientConfigs, options?: TClientOptions | undefined);
+    constructor(params: Readonly<{
+        credential: TClientCredential;
+        definition?: TClientDefinition;
+        options?: TClientOptions;
+    }>);
     /**
      * Sign JWT token with Ed25519 algorithm
      * @returns

package/dist/interfaces/client.interface.d.ts

@@ -1,15 +1,20 @@
+import type { defineResources } from "../definers";
 import type { IAccount, TDefaultAccountMetadata } from "./account.interface";
 import type { IAccountCredential } from "./accountCredential.interface";
-export type TClientConfigs = {
+export type TClientCredential = Readonly<{
     tenantId: string;
     appId: string;
     modeId: string;
     secretKey: string;
-};
-export type TClientOptions = {
+}>;
+export type TClientDefinition = Readonly<{
+    resources: ReturnType<typeof defineResources>["resources"];
+    policies: ReturnType<ReturnType<typeof defineResources>["definePolicies"]>;
+}>;
+export type TClientOptions = Readonly<{
     version?: 1;
     logs?: boolean;
-};
+}>;
 export interface IClient<TAccountMetadata extends TDefaultAccountMetadata = TDefaultAccountMetadata> {
     createPlainAccount(args: {
         identity: string;

package/dist/interfaces/index.d.ts

@@ -1,4 +1,4 @@
 export type { IAccount } from "./account.interface";
 export type { IAccountCredential } from "./accountCredential.interface";
 export type { TApiResponse } from "./base";
-export type { IClient, TAuthState, TClientConfigs, TClientOptions } from "./client.interface";
+export type { IClient, TAuthState, TClientCredential as TClientConfigs, TClientOptions } from "./client.interface";

package/dist/types/actionGuard.d.ts

@@ -0,0 +1,8 @@
+import type { TOptionalTupleUnorderedNonEmpty } from "../ultils/types";
+import type { TResourceDefinition } from "./resources";
+export type TActionGuardOptions<T extends readonly TResourceDefinition[]> = {
+    [R in T[number] as R["type"]]: {
+        resource: R["type"];
+        action: R["actions"][number] | TOptionalTupleUnorderedNonEmpty<R["actions"]>;
+    };
+}[T[number]["type"]];

package/dist/types/controllerGuard.d.ts

@@ -0,0 +1,6 @@
+import type { TResourceDefinition } from "./resources";
+export type TControllerGuardOptions<T extends readonly TResourceDefinition[]> = {
+    [R in T[number] as R["type"]]: {
+        resource: R["type"];
+    };
+}[T[number]["type"]];

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./actionGuard";
+export * from "./policies";
+export * from "./resources";

package/dist/types/policies.d.ts

@@ -0,0 +1,11 @@
+import type { TResourceDefinition } from "./resources";
+export type TPolicyDefinition<T extends readonly TResourceDefinition[] = readonly TResourceDefinition[]> = {
+    readonly alias: string;
+    readonly effect: "permit" | "deny";
+    readonly [key: string]: unknown;
+} & {
+    [R in T[number] as R["type"]]: {
+        readonly resource: R["type"];
+        readonly action: R["actions"][number];
+    };
+}[T[number]["type"]];

package/dist/types/resources.d.ts

@@ -0,0 +1,6 @@
+import type { TNonEmptyArray } from "../ultils/types";
+export type TResourceDefinition<T extends string = string, A extends TNonEmptyArray<string> = TNonEmptyArray<string>> = {
+    readonly type: T;
+    readonly actions: A;
+    readonly [key: string]: unknown;
+};

package/dist/ultils/functions/deepFreeze.d.ts

@@ -0,0 +1,7 @@
+type DeepReadonly<T> = T extends (...args: any[]) => any ? T : T extends readonly any[] ? {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+} : T extends object ? {
+    readonly [K in keyof T]: DeepReadonly<T[K]>;
+} : T;
+export declare function deepFreeze<const T>(obj: T): DeepReadonly<T>;
+export {};

package/dist/ultils/functions/index.d.ts

@@ -0,0 +1 @@
+export { deepFreeze } from "./deepFreeze";

package/dist/ultils/types/constructor.d.ts

@@ -0,0 +1 @@
+export type TConstructor<T, K extends any[] = any[]> = new (...args: K) => T;

package/dist/ultils/types/enforceUnique.d.ts

@@ -0,0 +1,8 @@
+type ValuesOfKey<Arr extends any[], K extends keyof any> = Arr extends [
+    infer Head,
+    ...infer Tail
+] ? Head extends Record<K, any> ? [Head[K], ...ValuesOfKey<Tail, K>] : ValuesOfKey<Tail, K> : [];
+type Includes<Arr extends any[], V> = Arr extends [infer H, ...infer R] ? [V] extends [H] ? true : Includes<R, V> : false;
+type HasDuplicate<Arr extends readonly any[], K extends keyof any> = Arr extends [infer Head, ...infer Tail] ? Head extends Record<K, any> ? Includes<ValuesOfKey<Tail, K>, Head[K]> extends true ? true : HasDuplicate<Tail, K> : HasDuplicate<Tail, K> : false;
+export type TEnforceUnique<Arr extends readonly any[], K extends keyof Arr[number]> = HasDuplicate<Arr, K> extends true ? ["Duplicate key found"] : Arr;
+export {};

package/dist/ultils/types/error.d.ts

@@ -0,0 +1,3 @@
+export type TError<Message extends string> = {
+    __error__: Message;
+};

package/dist/ultils/types/extractTuple.d.ts

@@ -0,0 +1 @@
+export type ExtractTuple<T> = T extends readonly [...infer U] ? U : never;

package/dist/ultils/types/inArray.d.ts

@@ -0,0 +1 @@
+export type TInArray<T, X> = T extends readonly [X, ...infer _Rest] ? true : T extends readonly [X] ? true : T extends readonly [infer _, ...infer Rest] ? TInArray<Rest, X> : false;

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

@@ -0,0 +1,14 @@
+export type { TConstructor } from "./constructor";
+export type { TEnforceUnique } from "./enforceUnique";
+export type { TError } from "./error";
+export type { ExtractTuple } from "./extractTuple";
+export type { TInArray } from "./inArray";
+export type { MergeTuple } from "./mergeTuple";
+export type { TNonEmptyArray } from "./noneEmptyArray";
+export type { TPartialTuple } from "./partialTuple";
+export type { TPartialTupleUnordered as TOptionalTupleUnordered } from "./partialTupleUnordered";
+export type { TOptionalTupleUnorderedNonEmpty } from "./partialTupleUnorderedNonEmpty";
+export type { TPartialTupleNonEmpty } from "./partialTurpleNonEmpty";
+export type { TPermutationTuple } from "./permutationTuple";
+export type { TShuffleTuple } from "./shuffleTuple";
+export type { TStrictPartial } from "./strictPartial";

package/dist/ultils/types/mergeTuple.d.ts

@@ -0,0 +1,3 @@
+export type MergeTuple<T extends readonly any[], U> = {
+    [K in keyof T]: T[K] & U;
+};

package/dist/ultils/types/noneEmptyArray.d.ts

@@ -0,0 +1 @@
+export type TNonEmptyArray<T> = readonly [T, ...T[]];

package/dist/ultils/types/partialTuple.d.ts

@@ -0,0 +1 @@
+export type TPartialTuple<T extends readonly any[]> = T extends readonly [infer Head, ...infer Tail] ? TPartialTuple<Tail> | [Head, ...TPartialTuple<Tail>] : [];

package/dist/ultils/types/partialTupleUnordered.d.ts

@@ -0,0 +1,3 @@
+import type { TPartialTuple } from "./partialTuple";
+import type { TPermutationTuple } from "./permutationTuple";
+export type TPartialTupleUnordered<T extends readonly any[]> = TPartialTuple<T> extends infer S ? S extends readonly any[] ? TPermutationTuple<S[number]> : never : never;

package/dist/ultils/types/partialTupleUnorderedNonEmpty.d.ts

@@ -0,0 +1,3 @@
+import type { TPartialTupleNonEmpty } from "./partialTurpleNonEmpty";
+import type { TPermutationTuple } from "./permutationTuple";
+export type TOptionalTupleUnorderedNonEmpty<T extends readonly any[]> = TPartialTupleNonEmpty<T> extends infer S ? S extends readonly any[] ? TPermutationTuple<S[number]> : never : never;

package/dist/ultils/types/partialTurpleNonEmpty.d.ts

@@ -0,0 +1,5 @@
+import type { TPartialTuple } from "./partialTuple";
+export type TPartialTupleNonEmpty<T extends readonly any[]> = T extends readonly [
+    infer Head,
+    ...infer Tail
+] ? [Head, ...TPartialTuple<Tail>] | TPartialTupleNonEmpty<Tail> : never;

package/dist/ultils/types/permutationTuple.d.ts

@@ -0,0 +1 @@
+export type TPermutationTuple<T, K = T> = [T] extends [never] ? [] : T extends any ? [T, ...TPermutationTuple<Exclude<K, T>>] : never;

package/dist/ultils/types/shuffleTuple.d.ts

@@ -0,0 +1,5 @@
+type Values<T> = T[keyof T];
+export type TShuffleTuple<U extends string | number> = [U] extends [never] ? [] : Values<{
+    [K in U]: [K, ...TShuffleTuple<Exclude<U, K>>];
+}>;
+export {};

package/dist/ultils/types/strictPartial.d.ts

@@ -0,0 +1,5 @@
+export type TStrictPartial<T> = {
+    [K in keyof T]?: T[K];
+} & {
+    [K in keyof T as K extends string ? never : never]: never;
+};

package/package.json

@@ -5,11 +5,11 @@
     },
     "dependencies": {
         "jose": "^6.1.0",
-        "zod": "^4.1.9"
+        "zod": "^4.1.12"
     },
     "devDependencies": {
         "@types/bun": "latest",
-        "typescript": "^5.9.2"
+        "typescript": "^5.9.3"
     },
     "files": [
         "./dist",
@@ -46,5 +46,5 @@
         "test": "bun --hot run __test/index.ts"
     },
     "types": "./dist/index.d.ts",
-    "version": "1.0.2-beta.3"
-}
+    "version": "1.1.0-beta.1"
+}

package/src/decorators/actionGuard.decorator.ts

@@ -1,5 +1,20 @@
+import type { TActionGuardOptions, TResourceDefinition } from "../types";
+import type { TConstructor } from "../ultils/types";
+
 import { Keys } from "../constants";
 
-export const ActionGuard = () => (target: Object, methodName: string) => {
-    Reflect.defineMetadata(Keys.guardMetadata, undefined, target, methodName);
-};
+export const ActionGuard =
+    <
+        const T extends readonly TResourceDefinition[] = readonly TResourceDefinition[],
+        K extends TConstructor<Object> | Object = Object
+    >(
+        options?: TActionGuardOptions<T>
+    ) =>
+    (target: K, methodName: string) => {
+        Reflect.defineMetadata(
+            Keys.guardMetadata,
+            options,
+            target.constructor,
+            methodName
+        );
+    };

package/src/decorators/controllerGuard.decorator.ts

@@ -1,5 +1,9 @@
+import type { TConstructor } from "../ultils/types";
+
 import { Keys } from "../constants";
 
-export const ControllerGuard = () => (target: Object) => {
-    Reflect.defineMetadata(Keys.guardMetadata, undefined, target);
-};
+export const ControllerGuard =
+    <T extends TConstructor<Object>>() =>
+    (target: T) => {
+        Reflect.defineMetadata(Keys.guardMetadata, undefined, target);
+    };

package/src/decorators/index.ts

@@ -1,3 +1 @@
-export { ActionGuard } from "./actionGuard.decorator";
 export { AuthState } from "./authState.decorator";
-export { ControllerGuard } from "./controllerGuard.decorator";

package/src/definers/index.ts

@@ -0,0 +1 @@
+export { defineResources } from "./resources";

package/src/definers/policies.ts

@@ -0,0 +1,24 @@
+import type { TPolicyDefinition } from "../types";
+import type { TEnforceUnique } from "../ultils/types";
+
+import { deepFreeze } from "../ultils/functions";
+
+export const definePolicies = <const K extends readonly TPolicyDefinition[]>(
+    policies: TEnforceUnique<K, "alias">
+) => {
+    if (
+        new Set([
+            ...policies
+                .map((policy) =>
+                    typeof policy === "string" ? undefined : policy.alias
+                )
+                .filter((policyAlias) => typeof policyAlias !== "undefined")
+        ]).size !== policies.length
+    ) {
+        throw new Error("Duplicated policy alias.");
+    }
+
+    return Object.freeze({
+        policies: deepFreeze(policies)
+    });
+};

package/src/definers/resources.ts

@@ -0,0 +1,47 @@
+import type { TPolicyDefinition, TResourceDefinition } from "../types";
+import type { TEnforceUnique } from "../ultils/types";
+
+import { deepFreeze } from "../ultils/functions";
+
+export const defineResources = <const T extends readonly TResourceDefinition[]>(
+    resources: TEnforceUnique<T, "type">
+) => {
+    if (
+        new Set([
+            ...resources
+                .map((resource) =>
+                    typeof resource === "string" ? undefined : resource.type
+                )
+                .filter((resourceType) => typeof resourceType !== "undefined")
+        ]).size !== resources.length
+    ) {
+        throw new Error("Duplicated resource type.");
+    }
+
+    return Object.freeze({
+        resources: deepFreeze(resources),
+        definePolicies: <const K extends readonly TPolicyDefinition<T>[]>(
+            policies: TEnforceUnique<K, "alias">
+        ) => {
+            if (
+                new Set([
+                    ...policies
+                        .map((policy) =>
+                            typeof policy === "string"
+                                ? undefined
+                                : policy.alias
+                        )
+                        .filter(
+                            (policyAlias) => typeof policyAlias !== "undefined"
+                        )
+                ]).size !== policies.length
+            ) {
+                throw new Error("Duplicated policy alias.");
+            }
+
+            return Object.freeze({
+                policies: deepFreeze(policies)
+            });
+        }
+    });
+};

package/src/entities/loader.ts

@@ -1,10 +1,24 @@
-import type { TClientConfigs, TClientOptions } from "../interfaces/client.interface";
+import type {
+    TClientCredential,
+    TClientDefinition,
+    TClientOptions
+} from "../interfaces/client.interface";
 
 import { Keys } from "../constants";
 import { Client } from "../instances/client";
 
-export const loader = async (clientConfigs: TClientConfigs, clientOptions?: TClientOptions) => {
-    const boolGuardClient = new Client(clientConfigs, clientOptions);
+export type TLoaderParameters = {
+    credential: TClientCredential;
+    definition?: TClientDefinition;
+    options?: TClientOptions;
+};
+
+export const loader = async ({
+    credential,
+    definition,
+    options
+}: TLoaderParameters) => {
+    const boolGuardClient = new Client({ credential, definition, options });
 
     await boolGuardClient.signToken();
 

package/src/entities/middleware.ts

@@ -4,7 +4,6 @@ import type { IClient, TAuthState } from "../interfaces/client.interface";
 import { Middleware as BoolMiddleware, Context, Inject, RequestHeaders } from "@bool-ts/core";
 import { object, string } from "zod/v4";
 import { Keys } from "../constants";
-import { Client } from "../instances";
 
 const headersSchema = object({
     authorization: string()
@@ -30,7 +29,7 @@ export class Middleware implements IMiddleware {
      * @param tenantAppModesService
      */
     constructor(
-        @Inject(Client)
+        @Inject(Keys.guardClient)
         private readonly clientInstance: IClient
     ) {}