@aeriajs/types 0.0.4 → 0.0.5

package/dist/api.d.ts

@@ -1,11 +1,12 @@
 import type { ObjectId } from 'mongodb';
-import type { Context, Description, SecurityPolicy, AccessControl, PackReferences } from '.';
+import type { Context, Contract, Description, SecurityPolicy, AccessControl, PackReferences } from '.';
 export type Collection<TCollection extends Collection = any> = {
     description: Description;
     item?: any;
     security?: SecurityPolicy;
     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}`;

package/dist/context.d.ts

@@ -5,7 +5,7 @@ export type CollectionModel<TDescription extends Description> = MongoCollection<
 type OmitContextParameter<TFunction> = 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;
 type UnionFunctions<TFunctions, TSchema extends CollectionDocument<any>> = {
-    [P in keyof TFunctions]: P extends keyof CollectionFunctions<any> ? CollectionFunctions<TSchema>[P] extends infer CollFunction ? CollFunction extends (...args: any[]) => any ? Extract<undefined, Parameters<CollFunction>[0]> extends never ? (payload: Parameters<CollFunction>[0], ...args: RestParameters<TFunctions[P]>) => ReturnType<CollFunction> : (payload?: Parameters<CollFunction>[0], ...args: RestParameters<TFunctions[P]>) => ReturnType<CollFunction> : never : never : OmitContextParameter<TFunctions[P]>;
+    [P in keyof TFunctions]: (P extends keyof CollectionFunctions<any> ? CollectionFunctions<TSchema>[P] extends infer CollFunction ? CollFunction extends (...args: any[]) => any ? Extract<undefined, Parameters<CollFunction>[0]> extends never ? (payload: Parameters<CollFunction>[0], ...args: RestParameters<TFunctions[P]>) => ReturnType<CollFunction> : (payload?: Parameters<CollFunction>[0], ...args: RestParameters<TFunctions[P]>) => ReturnType<CollFunction> : never : never : OmitContextParameter<TFunctions[P]>) extends (...args: infer Args) => infer Return ? Return extends Promise<any> ? (...args: Args) => Return : (...args: Args) => Promise<Return> : never;
 };
 export type IndepthCollection<TCollection> = TCollection extends {
     description: infer InferredDescription;
@@ -23,6 +23,8 @@ export type ContextOptions<TContext> = {
     parentContext?: TContext;
     collectionName?: string;
     token?: DecodedToken;
+    inherited?: boolean;
+    calledFunction?: string;
 };
 export type Context<TDescription extends Description = any, TFunctions = any> = {
     description: TDescription;
@@ -38,5 +40,7 @@ export type Context<TDescription extends Description = any, TFunctions = any> =
     response: GenericResponse;
     log: (message: string, details?: any) => Promise<any>;
     config: ApiConfig;
+    inherited: boolean;
+    calledFunction: string;
 };
 export {};

package/dist/functions.d.ts

@@ -1,16 +1,22 @@
 import type { FilterOperators, UpdateFilter, WithId, OptionalId, ObjectId } from 'mongodb';
-import type { PackReferences, Either, ValidationError } from '.';
+import type { PackReferences, Either, ValidationError, ACErrors, Context, Description } from '.';
 export type UploadAuxProps = {
     parentId: string;
     propertyName: string;
 };
+export type Pagination = {
+    recordsCount: number;
+    recordsTotal: number;
+    offset: number;
+    limit: number;
+};
 export type Filters<TDocument> = FilterOperators<TDocument>;
 export type What<TDocument> = Omit<UpdateFilter<TDocument>, keyof TDocument> & {
     [P in keyof TDocument]?: '_id' extends keyof TDocument[P] ? TDocument[P] | string : TDocument[P];
 };
-export type Projection<TDocument extends Record<string, any>> = keyof TDocument | '_id' extends infer DocumentProp ? TDocument extends string ? DocumentProp[] : string[] : never;
+export type Projection<TDocument> = keyof TDocument | '_id' extends infer DocumentProp ? TDocument extends string ? DocumentProp[] : string[] : never;
 export type QuerySort<TDocument> = Partial<Record<keyof WithId<TDocument>, 1 | -1>>;
-export type CollectionDocument<TDocument> = Pick<TDocument, Extract<keyof TDocument, string>>;
+export type CollectionDocument<TDocument> = TDocument;
 export type CountPayload<TDocument extends CollectionDocument<OptionalId<any>>> = {
     filters?: Filters<TDocument>;
 };
@@ -48,8 +54,17 @@ export type CollectionFunctions<TDocument extends CollectionDocument<OptionalId<
     count: (payload: CountPayload<TDocument>) => Promise<number>;
     get: (payload: GetPayload<TDocument>) => Promise<TDocument | null>;
     getAll: (payload?: GetAllPayload<TDocument>) => Promise<TDocument[]>;
-    insert: (payload: InsertPayload<TDocument>) => Promise<Either<ValidationError, TDocument>>;
+    insert: (payload: InsertPayload<TDocument>) => Promise<Either<ValidationError | ACErrors, TDocument>>;
     remove: (payload: RemovePayload<TDocument>) => Promise<TDocument>;
     removeAll: (payload: RemoveAllPayload) => Promise<any>;
     removeFile: (payload: RemoveFilePayload) => Promise<any>;
 };
+export type CollectionFunctionsPaginated<TDocument extends CollectionDocument<OptionalId<any>>> = Omit<CollectionFunctions<TDocument>, 'getAll'> & {
+    getAll: (payload?: GetAllPayload<TDocument>) => Promise<{
+        data: TDocument[];
+        pagination: Pagination;
+    }>;
+};
+export type CollectionFunctionsWithContext<TDocument extends CollectionDocument<OptionalId<any>>, TDescription extends Description = any, TFunctions = any> = {
+    [P in keyof CollectionFunctions<TDocument>]: (payload: Parameters<CollectionFunctions<TDocument>[P]>[0], context: Context<TDescription, TFunctions>) => ReturnType<CollectionFunctions<TDocument>[P]>;
+};

package/dist/http.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import type { ServerResponse, IncomingMessage } from 'http';
-import type { MapSchemaUnion } from './schema';
+import type { MapSchemaUnion, Property } from '.';
 export declare const REQUEST_METHODS: readonly ["GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS", "PATCH", "TRACE", "SEARCH"];
 export type RequestMethod = (typeof REQUEST_METHODS)[number];
 export type GenericRequest = {
@@ -18,4 +18,19 @@ export type EndpointFunction<TRouteMethod extends RequestMethod, TRouteResponse,
 export type MakeEndpoint<TRoute extends string, TRouteMethod extends RequestMethod, TRouteResponse = any, TRoutePayload = null> = TRoute extends `/${infer RouteTail}` ? MakeEndpoint<RouteTail, TRouteMethod, TRouteResponse, TRoutePayload> : TRoute extends `${infer Route}/${infer RouteTail}` ? Record<Route, MakeEndpoint<RouteTail, TRouteMethod, TRouteResponse, TRoutePayload>> : TRoute extends `(${string}` ? Record<string, EndpointFunction<TRouteMethod, TRouteResponse, TRoutePayload>> : Record<TRoute, EndpointFunction<TRouteMethod, TRouteResponse, TRoutePayload>>;
 type UnwrapResponse<TResponse> = TResponse extends readonly any[] ? TResponse : TResponse[];
 export type InferResponse<TResponse> = MapSchemaUnion<UnwrapResponse<TResponse>> extends infer InferredResponse ? InferredResponse | Promise<InferredResponse> : never;
+export type ContractRoles = {
+    roles?: Collections['user']['item']['roles'];
+};
+export type Contract = {
+    response: Property | Property[];
+} | {
+    payload: Property;
+} | {
+    query: Property;
+} | {
+    response?: Property | Property[];
+    payload?: Property;
+    query?: Property;
+};
+export type ContractWithRoles = ContractRoles & Contract;
 export {};

package/package.json

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