Increasing typed npm module types: a guide

Question

Increasing typed npm module types: a guide

I am currently working on enhancing the data types within the iam-policies npm package.

My main focus is on augmenting the ConditionKey type, or any other approach that can help me achieve the desired outcome.

Take a look at the types file of the package:

export declare type ConditionKey = string | number | boolean;
...
declare type Resolver = (data: ConditionKey, expected: ConditionKey) => boolean;
export interface ConditionResolver {
    [key: string]: Resolver;
}
export interface Context {
    [key: string]: ConditionKey | Context | string[] | number[];
}

Here's the content of my file iam-policies.d.ts:

import { conditionResolvers }         from './conditions';
import { ConditionMap, ConditionKey } from 'iam-policies/dist/src/types';

declare module 'iam-policies/dist/src/types' {
    type Resolver = (data: any, expected: any) => boolean;

    type ConditionResolver = {
        [key in keyof typeof conditionResolvers]?: Resolver
    }

export interface Context {
    [key: string]: any;
}

}

I am encountering errors such as "Duplicate Identifier 'ConditionBlock'", "Duplicate string index signature." and others indicating that the 'data' and 'expected' parameters in my conditionResolvers cannot be of type 'Date'. The tsconfig file I am using is similar to the one provided in the NestJS Typescript Starter.

My goal is to enhance the type of parameters in the Resolver object and the overall type structure. The ConditionResolver represents a collection of functions.

typescript

Answer 1

Answer №1

In preparation for future users, I enhanced the functionality through the method outlined below:

// Library Imports
import { EffectBlock, ActionBlock, ResourceBlock, NotResourceBlock, Patterns } from 'iam-policies/dist/src/types';
// Application Imports
import { conditionResolvers }                                                                     from './iam/conditions';

declare module 'iam-policies' {
    // Customization of ConditionMap
    interface ConditionMap {
        [key: string]: any;
    }

    type ConditionBlock = {
        [key in keyof typeof conditionResolvers]?: ConditionMap;
    }

    interface StatementInterface {
        sid?: string;
        effect?: EffectBlock;
        condition?: ConditionBlock;
    }

    type ConditionResolver = typeof conditionResolvers;

    // Definition of IdentityBasedType
    type IdentityBasedType = StatementInterface & (ActionBlock | NotActionBlock) & (ResourceBlock | NotResourceBlock);
    export interface Context {
        [key: string]: any;
    }
    export interface EvaluateIdentityBasedInterface {
        action: string;
        resource: string;
        context?: Context;
    }

    // Class Implementation for IdentityBasedPolicy
    class IdentityBasedPolicy {
        constructor(config: IdentityBasedType[], conditionResolver?: ConditionResolver);
        evaluate({ action, resource, context, }: EvaluateIdentityBasedInterface): boolean;
        can({ action, resource, context }: EvaluateIdentityBasedInterface): boolean;
        cannot({ action, resource, context, }: EvaluateIdentityBasedInterface): boolean;
    }

    // Definition of PrincipalMap and ResourceBasedType
    type PrincipalMap = {
        [key in EEntityPolicyEnumPrincipal]?: EClient | EClient[] | string | string[];
    }
    interface PrincipalBlock {
        principal: PrincipalMap | Patterns;
    }
    interface NotPrincipalBlock {
        principal: PrincipalMap | Patterns;
    }

    type ResourceBasedType = StatementInterface & (PrincipalBlock | NotPrincipalBlock) & (ActionBlock | NotActionBlock) & (ResourceBlock | NotResourceBlock | {});

    export interface EvaluateResourceBasedInterface extends EvaluateIdentityBasedInterface {
        principal: string;
        principalType?: string;
    }

    // Class Implementation for ResourceBasedPolicy
    class ResourceBasedPolicy {
        constructor(config: ResourceBasedType[], conditionResolver?: ConditionResolver);
        evaluate({ principal, action, resource, principalType, context, }: EvaluateResourceBasedInterface): boolean;
        can({ principal, action, resource, principalType, context, }: EvaluateResourceBasedInterface): boolean;
        cannot({ principal, action, resource, principalType, context, }: EvaluateResourceBasedInterface): boolean;
    }
}

It's important to note that modifying the types of a module directly is not feasible, as confirmed by a quick search. Instead, I adjusted the higher-level types, specifically the classes, to align with my requirements.

Answer 2

In preparation for future users, I enhanced the functionality through the method outlined below:

// Library Imports
import { EffectBlock, ActionBlock, ResourceBlock, NotResourceBlock, Patterns } from 'iam-policies/dist/src/types';
// Application Imports
import { conditionResolvers }                                                                     from './iam/conditions';

declare module 'iam-policies' {
    // Customization of ConditionMap
    interface ConditionMap {
        [key: string]: any;
    }

    type ConditionBlock = {
        [key in keyof typeof conditionResolvers]?: ConditionMap;
    }

    interface StatementInterface {
        sid?: string;
        effect?: EffectBlock;
        condition?: ConditionBlock;
    }

    type ConditionResolver = typeof conditionResolvers;

    // Definition of IdentityBasedType
    type IdentityBasedType = StatementInterface & (ActionBlock | NotActionBlock) & (ResourceBlock | NotResourceBlock);
    export interface Context {
        [key: string]: any;
    }
    export interface EvaluateIdentityBasedInterface {
        action: string;
        resource: string;
        context?: Context;
    }

    // Class Implementation for IdentityBasedPolicy
    class IdentityBasedPolicy {
        constructor(config: IdentityBasedType[], conditionResolver?: ConditionResolver);
        evaluate({ action, resource, context, }: EvaluateIdentityBasedInterface): boolean;
        can({ action, resource, context }: EvaluateIdentityBasedInterface): boolean;
        cannot({ action, resource, context, }: EvaluateIdentityBasedInterface): boolean;
    }

    // Definition of PrincipalMap and ResourceBasedType
    type PrincipalMap = {
        [key in EEntityPolicyEnumPrincipal]?: EClient | EClient[] | string | string[];
    }
    interface PrincipalBlock {
        principal: PrincipalMap | Patterns;
    }
    interface NotPrincipalBlock {
        principal: PrincipalMap | Patterns;
    }

    type ResourceBasedType = StatementInterface & (PrincipalBlock | NotPrincipalBlock) & (ActionBlock | NotActionBlock) & (ResourceBlock | NotResourceBlock | {});

    export interface EvaluateResourceBasedInterface extends EvaluateIdentityBasedInterface {
        principal: string;
        principalType?: string;
    }

    // Class Implementation for ResourceBasedPolicy
    class ResourceBasedPolicy {
        constructor(config: ResourceBasedType[], conditionResolver?: ConditionResolver);
        evaluate({ principal, action, resource, principalType, context, }: EvaluateResourceBasedInterface): boolean;
        can({ principal, action, resource, principalType, context, }: EvaluateResourceBasedInterface): boolean;
        cannot({ principal, action, resource, principalType, context, }: EvaluateResourceBasedInterface): boolean;
    }
}

It's important to note that modifying the types of a module directly is not feasible, as confirmed by a quick search. Instead, I adjusted the higher-level types, specifically the classes, to align with my requirements.

Increasing typed npm module types: a guide

Answer №1

Similar questions

What is the best way to create a method that waits for a POST request to complete?

Avoiding Overload Conflicts: TypeScript and the Power of Generic Methods

Error: The function cannot be executed on an immutable object in React Native Jest unit testing with Typescript

Double-executing methods in a component

How can React with TypeScript dynamically extend type definitions based on component props?

The Crimson Thread when incorporating tsx into Next.js

Error encountered during execution of Angular application, specifically TS2305 error?

Assign the private members of the class to the arguments of the constructor

Utilizing type maps within nested objects in Typescript: A comprehensive guide

Utilizing an Observable in an Angular 6 service to ensure proper synchronization with Okta token present in local storage

Upgrade your AngularJS Directive to an Angular 2.x+ Directive by using an HTML decorator

Prevent selection of items in ng-select. Modifying the default item selection behavior in ng-select

Should private members be kept confidential during program execution?

The specified 'Promise<Modules>' type argument cannot be assigned to the parameter of type '(params: any) => Promise<Modules>' in the current context

Exploring TypeORM: Leveraging the In() function within @ManyToMany relationships

Utilizing an object as a prop within React-router's Link functionality

Creating fixtures with Playwright is a simple process that can greatly enhance

Passing the user input from a textbox to a directive's input string in Angular 9 using Typescript

Enhancing external TypeScript modules

What is the best way to extract the primary base64 value from reader.result?