@aeriajs/types 0.0.95 → 0.0.96

package/dist/context.d.ts

@@ -1,4 +1,4 @@
-import type { Collection as MongoCollection, WithId } from 'mongodb';
+import type { Collection as MongoCollection } from 'mongodb';
 import type { AcceptedRole } from './token.js';
 import type { Collection } from './collection.js';
 import type { ApiConfig } from './config.js';
@@ -8,24 +8,25 @@ import type { Result } from './result.js';
 import type { EndpointError } from './endpointError.js';
 import type { GenericRequest, GenericResponse, HTTPStatus } from './http.js';
 import type { PackReferences, SchemaWithId } from './schema.js';
+import type { JsonSchema } from './property.js';
 import type { RateLimitingParams, RateLimitingError } from './security.js';
 import type { Token } from './token.js';
 export type CollectionModel<TDescription extends Description> = MongoCollection<Omit<PackReferences<SchemaWithId<TDescription>>, '_id'>>;
 type OmitContextParameter<TFunction> = TFunction extends () => unknown ? TFunction : TFunction extends (payload: undefined, ...args: any[]) => infer Return ? () => Return : TFunction extends (payload: infer Payload, context: Context<any>, ...args: infer Rest) => infer Return ? (payload: Payload, ...args: Rest) => Return : never;
 type RestParameters<TFunction> = TFunction extends (payload: any, context: Context<any>, ...args: infer Rest) => unknown ? Rest : never;
-type UnionFunctions<TFunctions, TSchema extends WithId<unknown>> = {
+type UnionFunctions<TFunctions, TSchema extends JsonSchema> = {
     [P in keyof TFunctions]: (P extends keyof CollectionFunctions ? CollectionFunctions<TSchema>[P] extends infer CollFunction ? CollFunction extends (...args: infer Args) => unknown ? Extract<undefined, Args[0]> extends never ? (payload: Args[0], ...args: RestParameters<TFunctions[P]>) => ReturnType<CollFunction> : (payload?: Args[0], ...args: RestParameters<TFunctions[P]>) => ReturnType<CollFunction> : never : never : OmitContextParameter<TFunctions[P]>) extends (...args: infer Args) => infer Return ? Return extends Promise<unknown> ? (...args: Args) => Return : (...args: Args) => Promise<Return> : never;
 };
 export type IndepthCollection<TCollection> = TCollection extends {
     description: infer InferredDescription;
     functions?: infer CollFunctions;
-} ? Omit<TCollection, 'functions'> & {
+} ? InferredDescription extends JsonSchema ? Omit<TCollection, 'functions'> & {
     item: SchemaWithId<InferredDescription>;
-    functions: UnionFunctions<CollFunctions, SchemaWithId<InferredDescription>>;
+    functions: UnionFunctions<CollFunctions, InferredDescription>;
     originalFunctions: CollFunctions;
     model: InferredDescription extends Description ? CollectionModel<InferredDescription> : never;
     middlewares?: Collection['middlewares'];
-} : TCollection;
+} : never : TCollection;
 export type IndepthCollections = {
     [P in keyof Collections]: IndepthCollection<Collections[P]>;
 };

package/dist/functions.d.ts

@@ -1,7 +1,8 @@
 import type { FilterOperators, StrictFilter as Filter, WithId, ObjectId } from 'mongodb';
 import type { Result, ExtractError } from './result.js';
 import type { EndpointError } from './endpointError.js';
-import type { PackReferences } from './schema.js';
+import type { SchemaWithId, PackReferences } from './schema.js';
+import type { JsonSchema } from './property.js';
 import type { ACError } from './accessControl.js';
 import type { ValidationErrorCode, TraverseError } from './validation.js';
 import type { HTTPStatus, WithACErrors } from './http.js';
@@ -78,22 +79,26 @@ export type PaginatedGetAllReturnType<TDocument> = Result.Either<ExtractError<Ge
     data: TDocument[];
     pagination: Pagination;
 }>;
-export type CollectionFunctions<TDocument extends WithId<unknown> = WithId<unknown>> = {
-    count: (payload: CountPayload<TDocument>) => Promise<CountReturnType>;
-    get: (payload: GetPayload<TDocument>) => Promise<GetReturnType<TDocument>>;
-    getAll: (payload?: GetAllPayload<TDocument>) => Promise<GetAllReturnType<TDocument>>;
-    insert: (payload: InsertPayload<TDocument>) => Promise<InsertReturnType<TDocument>>;
-    remove: (payload: RemovePayload<TDocument>) => Promise<RemoveReturnType<TDocument>>;
+export type CollectionFunctions<TSchema extends JsonSchema = JsonSchema> = SchemaWithId<TSchema> extends infer InferredDocument ? InferredDocument extends WithId<unknown> ? {
+    count: (payload: CountPayload<InferredDocument>) => Promise<CountReturnType>;
+    get: (payload: GetPayload<InferredDocument>) => Promise<GetReturnType<InferredDocument>>;
+    getAll: (payload?: GetAllPayload<InferredDocument>) => Promise<GetAllReturnType<InferredDocument>>;
+    insert: (payload: InsertPayload<SchemaWithId<TSchema, {
+        keepTempIds: true;
+    }>>) => Promise<InsertReturnType<InferredDocument>>;
+    remove: (payload: RemovePayload<InferredDocument>) => Promise<RemoveReturnType<InferredDocument>>;
     removeAll: (payload: RemoveAllPayload) => Promise<unknown>;
     removeFile: (payload: RemoveFilePayload) => Promise<unknown>;
-};
-export type CollectionFunctionsSDK<TDocument extends WithId<unknown> = WithId<unknown>> = {
-    count: (payload: CountPayload<TDocument>) => Promise<WithACErrors<CountReturnType>>;
-    get: (payload: GetPayload<TDocument>) => Promise<WithACErrors<GetReturnType<TDocument>>>;
-    getAll: (payload?: GetAllPayload<TDocument>) => Promise<WithACErrors<PaginatedGetAllReturnType<TDocument>>>;
-    insert: (payload: InsertPayload<TDocument>) => Promise<WithACErrors<InsertReturnType<TDocument>>>;
-    remove: (payload: RemovePayload<TDocument>) => Promise<WithACErrors<RemoveReturnType<TDocument>>>;
+} : never : never;
+export type CollectionFunctionsSDK<TSchema extends JsonSchema = JsonSchema> = SchemaWithId<TSchema> extends infer InferredDocument ? InferredDocument extends WithId<unknown> ? {
+    count: (payload: CountPayload<InferredDocument>) => Promise<WithACErrors<CountReturnType>>;
+    get: (payload: GetPayload<InferredDocument>) => Promise<WithACErrors<GetReturnType<InferredDocument>>>;
+    getAll: (payload?: GetAllPayload<InferredDocument>) => Promise<WithACErrors<PaginatedGetAllReturnType<InferredDocument>>>;
+    insert: (payload: InsertPayload<SchemaWithId<TSchema, {
+        keepTempIds: true;
+    }>>) => Promise<WithACErrors<InsertReturnType<InferredDocument>>>;
+    remove: (payload: RemovePayload<InferredDocument>) => Promise<WithACErrors<RemoveReturnType<InferredDocument>>>;
     removeAll: (payload: RemoveAllPayload) => Promise<unknown>;
     removeFile: (payload: RemoveFilePayload) => Promise<unknown>;
-};
+} : never : never;
 export {};

package/dist/schema.d.ts

@@ -43,13 +43,16 @@ export type InferProperty<T> = T extends TestType<{
 type ExtractRequiredPropNames<T> = T extends readonly (infer PropName)[] ? PropName : Record<never, never> extends T ? null : keyof {
     [K in keyof T as T[K] extends true ? K : never]: never;
 };
-export type InferSchema<TSchema> = MergeReferences<TSchema> extends infer MappedTypes ? TSchema extends {
+type SchemaOptions = {
+    readonly keepTempIds?: boolean;
+};
+export type InferSchema<TSchema, TSchemaOptions extends SchemaOptions = {}> = MergeReferences<TSchema, TSchemaOptions> extends infer MappedTypes ? TSchema extends {
     required: readonly [];
 } ? Partial<MappedTypes> : TSchema extends {
     required: infer InferredRequired;
 } ? ExtractRequiredPropNames<InferredRequired> extends infer RequiredPropName ? Pick<MappedTypes, Extract<keyof MappedTypes, RequiredPropName>> extends infer RequiredProps ? RequiredProps & Partial<Exclude<MappedTypes, keyof RequiredProps>> : never : Partial<MappedTypes> : MappedTypes : never;
-export type Schema<TSchema> = CaseTimestamped<TSchema, CaseOwned<TSchema, InferSchema<TSchema>>>;
-export type SchemaWithId<TSchema> = Schema<TSchema> & {
+export type Schema<TSchema, TSchemaOptions extends SchemaOptions = {}> = CaseTimestamped<TSchema, CaseOwned<TSchema, InferSchema<TSchema, TSchemaOptions>>>;
+export type SchemaWithId<TSchema, TSchemaOptions extends SchemaOptions = {}> = Schema<TSchema, TSchemaOptions> & {
     _id: ObjectId;
 };
 export type InferProperties<TSchema> = TSchema extends readonly unknown[] ? TSchema extends readonly (infer SchemaOption)[] ? SchemaOption extends unknown ? SchemaOption extends {
@@ -67,7 +70,7 @@ export type FilterReadonlyProperties<TProperties> = {
         readOnly: true;
     } ? P : never]: InferProperty<TProperties[P]>;
 };
-type MapReferences<TSchema> = TSchema extends {
+type MapReferences<TSchema, TSchemaOptions extends SchemaOptions> = TSchema extends {
     properties: infer Properties;
 } ? {
     -readonly [P in keyof Properties as Properties[P] extends TestType<{
@@ -78,11 +81,19 @@ type MapReferences<TSchema> = TSchema extends {
         };
     }> ? P : never]: Properties[P] extends infer Prop ? Prop extends TestType<{
         $ref: infer K;
-    }> ? K extends keyof Collections ? Collections[K]['item'] : never : Prop extends TestType<{
+    }> ? K extends keyof Collections ? TSchemaOptions extends {
+        keepTempIds: true;
+    } ? K extends 'file' ? ObjectId | string | {
+        tempId: ObjectId | string;
+    } : Collections[K]['item'] : Collections[K]['item'] : never : Prop extends TestType<{
         items: TestType<{
             $ref: infer K;
         }>;
-    }> ? K extends keyof Collections ? Collections[K]['item'][] : never : never : never;
+    }> ? K extends keyof Collections ? TSchemaOptions extends {
+        keepTempIds: true;
+    } ? K extends 'file' ? (ObjectId | string | {
+        tempId: ObjectId | string;
+    })[] : Collections[K]['item'][] : Collections[K]['item'][] : never : never : never;
 } : never;
 type PackReferencesAux<T> = T extends (...args: unknown[]) => unknown ? T : T extends ObjectId ? T : T extends {
     _id: infer Id;
@@ -92,5 +103,5 @@ type CombineProperties<TSchema> = TSchema extends {
 } ? FilterReadonlyProperties<Properties> extends infer ReadonlyProperties ? Readonly<ReadonlyProperties> & {
     [P in Exclude<keyof Properties, keyof ReadonlyProperties>]: InferProperty<Properties[P]>;
 } : never : never;
-type MergeReferences<TSchema> = CombineProperties<TSchema> extends infer CombinedProperties ? MapReferences<TSchema> extends infer MappedReferences ? MappedReferences & Omit<CombinedProperties, keyof MappedReferences> : never : never;
+type MergeReferences<TSchema, TSchemaOptions extends SchemaOptions> = CombineProperties<TSchema> extends infer CombinedProperties ? MapReferences<TSchema, TSchemaOptions> extends infer MappedReferences ? MappedReferences & Omit<CombinedProperties, keyof MappedReferences> : never : never;
 export {};

package/package.json

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