@aeriajs/types 0.0.29 → 0.0.30

package/dist/accessControl.d.ts

@@ -1,4 +1,4 @@
-import type { Collection } from '.';
+import type { AuthenticatedToken, Collection, Token, UserRole } from '.';
 export declare enum ACErrors {
     AssetNotFound = "ASSET_NOT_FOUND",
     AuthenticationError = "AUTHENTICATION_ERROR",
@@ -18,14 +18,16 @@ export type Role<TCollection extends Collection = any, TAccessControl extends Ac
     grant?: readonly (keyof TCollection['functions'])[];
     forbid?: readonly (keyof TCollection['functions'])[];
 };
-export type Roles<TCollection extends Collection = any, TAccessControl extends AccessControl<TCollection> = any> = Record<string, Role<TCollection, TAccessControl>>;
-export type InternalAccessControl<TCollection extends Collection = any, TAccessControl extends AccessControl<TCollection, TAccessControl> = any> = {
-    roles?: Roles<TCollection, TAccessControl>;
+export type AccessControl<TCollection extends Collection = any, TAccessControl extends AccessControl<TCollection, TAccessControl> = any> = {
+    roles?: Partial<Record<string, Role<TCollection, TAccessControl>>>;
     availableRoles?: keyof TAccessControl['roles'];
     parent?: TAccessControl['roles'];
 };
-export type AccessControl<TCollection extends Collection = any, TAccessControl extends AccessControl<TCollection, TAccessControl> = any> = InternalAccessControl<TCollection, TAccessControl>;
-export type ACProfile = {
-    readonly roles?: string[];
-    readonly allowed_functions?: string[];
+export type NonCircularAccessControl<TCollection extends Collection = any, TAccessControl extends AccessControl<TCollection, TAccessControl> = any> = {
+    roles?: Record<string, Role<TCollection, TAccessControl>>;
+    availableRoles?: keyof TAccessControl['roles'];
+    parent?: TAccessControl['roles'];
 };
+export type ExpectToken<TToken extends Token, TRole extends UserRole | UserRole[]> = (TRole extends any[] ? TRole[number] : TRole) extends infer NormalizedRole ? TToken extends AuthenticatedToken ? NormalizedRole extends TToken['roles'][number] ? TToken : Omit<TToken, 'roles'> & {
+    roles: readonly NormalizedRole[];
+} : TToken : never;

package/dist/api.d.ts

@@ -1,28 +1,25 @@
 import type { ObjectId } from 'mongodb';
-import type { Context, Contract, Description, SecurityPolicy, AccessControl, PackReferences } from '.';
+import type { Context, Contract, Description, CollectionSecurityPolicy, AccessControl, PackReferences } from '.';
 export type Collection<TCollection extends Collection = any> = {
     description: Description;
     item?: any;
-    security?: SecurityPolicy;
+    security?: CollectionSecurityPolicy<TCollection>;
     accessControl?: AccessControl<TCollection>;
     functions?: Record<string, (payload: any, context: Context, ...args: any[]) => any>;
     functionContracts?: Record<string, Contract>;
 };
 export type AssetType = keyof Collection;
 export type FunctionPath = `${string}@${string}`;
-export type UserACProfile = {
-    readonly roles: string[];
-    readonly allowed_functions?: string[];
-};
-export type AuthenticatedToken = {
+export type UserRole = Collections['user']['item']['roles'][number];
+export type AuthenticatedToken<TAcceptedRole = string> = {
     authenticated: true;
     sub: ObjectId;
-    roles: string[];
+    roles: readonly TAcceptedRole[];
+    allowed_functions?: readonly FunctionPath[];
     userinfo: PackReferences<Collections['user']['item']>;
-    allowed_functions?: FunctionPath[];
 };
 export type UnauthenticatedToken = {
     authenticated: false;
     sub: null;
 };
-export type DecodedToken = AuthenticatedToken | UnauthenticatedToken;
+export type Token<TAcceptedRole = string> = AuthenticatedToken<TAcceptedRole> | UnauthenticatedToken;

package/dist/config.d.ts

@@ -1,8 +1,8 @@
 import type { RouteContext, RouteUri, RateLimitingParams } from '.';
 export type ApiConfig = {
     secret?: string;
-    apiUrl?: string;
-    apiBase?: RouteUri;
+    baseUrl?: RouteUri;
+    publicUrl?: string;
     port?: number;
     paginationLimit?: number;
     database?: {

package/dist/context.d.ts

@@ -1,6 +1,6 @@
 import type { Collection as MongoCollection } from 'mongodb';
 import type { GenericRequest, GenericResponse } from './http';
-import type { Either, Description, PackReferences, SchemaWithId, FunctionPath, DecodedToken, ApiConfig, CollectionDocument, CollectionFunctions, RateLimitingParams, RateLimitingErrors } from '.';
+import type { Either, Description, PackReferences, SchemaWithId, FunctionPath, Token, ApiConfig, CollectionDocument, CollectionFunctions, RateLimitingParams, RateLimitingErrors } from '.';
 export type CollectionModel<TDescription extends Description> = MongoCollection<Omit<PackReferences<SchemaWithId<TDescription>>, '_id'>>;
 type OmitContextParameter<TFunction> = TFunction extends () => any ? TFunction : TFunction extends (payload: undefined, ...args: any[]) => infer Return ? () => Return : TFunction extends (payload: infer Payload, context: Context, ...args: infer Rest) => infer Return ? (payload: Payload, ...args: Rest) => Return : never;
 type RestParameters<TFunction> = TFunction extends (payload: any, context: Context, ...args: infer Rest) => any ? Rest : never;
@@ -22,14 +22,14 @@ export type ContextOptions = {
     config?: ApiConfig;
     parentContext?: RouteContext | Context;
     collectionName?: string;
-    token?: DecodedToken;
+    token?: Token;
     inherited?: boolean;
     calledFunction?: string;
 };
-export type RouteContext = {
+export type RouteContext<TAcceptedRole = string> = {
     collections: IndepthCollections;
     functionPath: FunctionPath;
-    token: DecodedToken;
+    token: Token<TAcceptedRole>;
     request: GenericRequest;
     response: GenericResponse;
     log: (message: string, details?: any) => Promise<any>;

package/dist/contract.d.ts

@@ -1,9 +1,9 @@
-import type { Property, InferProperty, InferResponse, Context } from '.';
+import type { Property, InferProperty, InferResponse, Context, UserRole } from '.';
 export type ContractBase = {
     builtin?: boolean;
 };
 export type ContractRoles = {
-    roles?: (Collections['user']['item']['roles'][number] | 'root' | 'guest')[];
+    roles?: (UserRole | 'root' | 'guest')[];
 };
 export type Contract = ContractBase & ({
     response: Property | Property[];

package/dist/security.d.ts

@@ -1,15 +1,27 @@
+import type { Collection } from './api.js';
 export declare enum RateLimitingErrors {
     Unauthenticated = "UNAUTHENTICATED",
     LimitReached = "LIMIT_REACHED"
 }
+export type DiscriminationStrategy = 'tenant' | 'ip';
+export type RateLimitingWithScale = {
+    scale: number;
+};
+export type RateLimitingWithLimit = {
+    limit: number;
+};
 export type RateLimitingParams = {
-    strategy: 'tenant' | 'ip';
-    limit?: number;
-    scale?: number;
+    strategy: DiscriminationStrategy;
     increment?: number;
+} & (RateLimitingWithLimit | RateLimitingWithScale | (RateLimitingWithLimit & RateLimitingWithScale));
+export type LoggingLevel = 'debug' | 'info' | 'error' | 'critical';
+export type LoggingParams = {
+    strategy: DiscriminationStrategy;
+    level: LoggingLevel;
 };
 export type SecurityPolicy = {
     allowQueryOperators?: string[];
-    rateLimiting?: Record<string, RateLimitingParams>;
-    accessControl?: any;
+    rateLimiting?: RateLimitingParams;
+    logging?: LoggingParams;
 };
+export type CollectionSecurityPolicy<TCollection extends Collection = any> = Partial<Record<keyof TCollection['functions'], SecurityPolicy>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aeriajs/types",
-  "version": "0.0.29",
+  "version": "0.0.30",
   "description": "",
   "main": "dist/index.js",
   "module": "dist/index.mjs",