@aeriajs/types 0.0.29 → 0.0.31

package/dist/accessControl.d.ts

@@ -18,14 +18,13 @@ 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'];
 };

package/dist/api.d.ts

@@ -1,28 +1,26 @@
 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 AcceptedRole = UserRole | UserRole[] | null | unknown;
 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] | 'root' | 'guest';
+export type AuthenticatedToken<TAcceptedRole extends AcceptedRole = null> = {
     authenticated: true;
     sub: ObjectId;
-    roles: string[];
+    roles: readonly (TAcceptedRole extends null ? string : 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 extends AcceptedRole = null> = (TAcceptedRole extends any[] ? TAcceptedRole[number] : TAcceptedRole) extends infer NormalizedRole ? NormalizedRole extends null | 'guest' ? AuthenticatedToken | UnauthenticatedToken : AuthenticatedToken<NormalizedRole> : never;

package/dist/condition.d.ts

@@ -1,4 +1,4 @@
-import type { JsonSchema, PropertiesWithId } from './property';
+import type { JsonSchema, PropertiesWithId } from './property.js';
 export type FinalOperator = 'equal' | 'in' | 'gt' | 'lt' | 'gte' | 'lte';
 export type FinalCondition<TSchema extends JsonSchema = any> = {
     operator: FinalOperator;

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 { GenericRequest, GenericResponse } from './http.js';
+import type { Either, Description, PackReferences, SchemaWithId, FunctionPath, Token, ApiConfig, CollectionDocument, CollectionFunctions, RateLimitingParams, RateLimitingErrors, AcceptedRole } 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 extends AcceptedRole = null> = {
     collections: IndepthCollections;
     functionPath: FunctionPath;
-    token: DecodedToken;
+    token: Token<TAcceptedRole>;
     request: GenericRequest;
     response: GenericResponse;
     log: (message: string, details?: any) => Promise<any>;
@@ -49,6 +49,6 @@ export type Context<TDescription extends Description = any, TFunctions = any> =
     collection: TDescription['$id'] extends keyof Collections ? IndepthCollection<{
         description: TDescription;
         functions: TFunctions;
-    }> : TDescription;
+    }> : IndepthCollection<any>;
 };
 export {};

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[];
 };
 export type Contract = ContractBase & ({
     response: Property | Property[];

package/dist/description.d.ts

@@ -1,6 +1,7 @@
 import type { IconStyle, PhosphorIcon } from '@phosphor-icons/core';
-import type { JsonSchema, PropertiesWithId } from './property';
-import type { Condition } from './condition';
+import type { JsonSchema, PropertiesWithId } from './property.js';
+import type { Condition } from './condition.js';
+import type { OwnershipMode } from './security.js';
 export type CollectionPresets = 'crud' | 'duplicate' | 'remove' | 'removeAll' | 'owned' | 'timestamped' | 'view';
 export type Icon = PhosphorIcon['name'] | `${IconStyle}:${PhosphorIcon['name']}`;
 export type CollectionAction<TDescription extends Description> = Readonly<{
@@ -71,33 +72,33 @@ export type SearchOptions<TDescription extends Description> = {
 };
 export type Description<TDescription extends Description = any> = JsonSchema<TDescription> & {
     title?: string;
-    categories?: string[];
+    categories?: readonly string[];
     system?: boolean;
     inline?: boolean;
     preferred?: Record<string, Partial<TDescription | Description>>;
     icon?: Icon;
     options?: CollectionOptions<TDescription>;
-    indexes?: ReadonlyArray<string>;
+    indexes?: readonly (keyof TDescription['properties'])[];
     defaults?: Record<string, any>;
-    owned?: boolean | 'always';
+    owned?: OwnershipMode;
     temporary?: {
         index: keyof TDescription['properties'];
         expireAfterSeconds: number;
     };
     timestamps?: false;
-    immutable?: boolean | ReadonlyArray<string>;
-    route?: ReadonlyArray<string>;
-    presets?: ReadonlyArray<CollectionPresets>;
-    table?: ReadonlyArray<PropertiesWithId<TDescription>>;
-    tableMeta?: ReadonlyArray<PropertiesWithId<TDescription>>;
+    immutable?: boolean | readonly string[];
+    route?: readonly string[];
+    presets?: readonly CollectionPresets[];
+    table?: readonly PropertiesWithId<TDescription>[];
+    tableMeta?: readonly PropertiesWithId<TDescription>[];
     filtersPresets?: Record<string, FiltersPreset<TDescription>>;
     freshItem?: Partial<Record<PropertiesWithId<TDescription>, any>>;
-    form?: ReadonlyArray<PropertiesWithId<TDescription>> | Record<PropertiesWithId<TDescription>, string[]>;
-    writable?: ReadonlyArray<PropertiesWithId<TDescription>>;
-    filters?: ReadonlyArray<PropertiesWithId<TDescription> | {
+    form?: readonly PropertiesWithId<TDescription>[] | Record<PropertiesWithId<TDescription>, string[]>;
+    writable?: readonly PropertiesWithId<TDescription>[];
+    filters?: readonly (PropertiesWithId<TDescription> | {
         property: PropertiesWithId<TDescription>;
         default: string;
-    }>;
+    })[];
     layout?: Layout<TDescription>;
     formLayout?: Partial<FormLayout<TDescription>>;
     tableLayout?: Partial<TableLayout<TDescription>>;

package/dist/security.d.ts

@@ -1,15 +1,28 @@
+import type { Collection } from './api.js';
+export type OwnershipMode = boolean | 'always' | 'on-write';
 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.31",
   "description": "",
   "main": "dist/index.js",
   "module": "dist/index.mjs",