@aeriajs/types 0.0.97 → 0.0.99

package/dist/config.d.ts

@@ -29,6 +29,7 @@ export type ApiConfig = {
         logSuccessfulAuthentications?: boolean;
         authenticationRateLimiting?: RateLimitingParams | null;
         allowSignup?: boolean;
+        allowInsecureOperators?: boolean;
         signupDefaults?: {
             roles?: string[];
             active?: boolean;

package/dist/functionSchemas.d.ts

@@ -0,0 +1,123 @@
+import { ACError } from './accessControl.js';
+import { HTTPStatus } from './http.js';
+import { ValidationErrorCode, TraverseError } from './validation.js';
+export declare const insertErrorSchema: () => {
+    readonly type: "object";
+    readonly properties: {
+        readonly _tag: {
+            readonly const: "Error";
+        };
+        readonly result: {
+            readonly const: undefined;
+        };
+        readonly error: {
+            readonly type: "object";
+            readonly required: readonly ["httpStatus", "code"];
+            readonly properties: {
+                readonly httpStatus: {
+                    readonly enum: [HTTPStatus.Forbidden, HTTPStatus.NotFound, HTTPStatus.UnprocessableContent, HTTPStatus.BadRequest];
+                };
+                readonly code: {
+                    readonly enum: [ACError.InsecureOperator, ACError.OwnershipError, ACError.ResourceNotFound, ACError.TargetImmutable, ACError.MalformedInput, ValidationErrorCode.EmptyTarget, ValidationErrorCode.InvalidProperties, ValidationErrorCode.MissingProperties, TraverseError.InvalidDocumentId, TraverseError.InvalidTempfile];
+                };
+                readonly message: {
+                    readonly type: "string";
+                };
+                readonly details: {
+                    readonly type: "object";
+                    readonly variable: true;
+                };
+            };
+        };
+    };
+};
+export declare const getErrorSchema: () => {
+    readonly type: "object";
+    readonly properties: {
+        readonly _tag: {
+            readonly const: "Error";
+        };
+        readonly result: {
+            readonly const: undefined;
+        };
+        readonly error: {
+            readonly type: "object";
+            readonly required: readonly ["httpStatus", "code"];
+            readonly properties: {
+                readonly httpStatus: {
+                    readonly enum: [HTTPStatus.Forbidden, HTTPStatus.NotFound, HTTPStatus.BadRequest];
+                };
+                readonly code: {
+                    readonly enum: [ACError.ResourceNotFound, ACError.OwnershipError, ACError.InsecureOperator, ACError.MalformedInput];
+                };
+                readonly message: {
+                    readonly type: "string";
+                };
+                readonly details: {
+                    readonly type: "object";
+                    readonly variable: true;
+                };
+            };
+        };
+    };
+};
+export declare const getAllErrorSchema: () => {
+    readonly type: "object";
+    readonly properties: {
+        readonly _tag: {
+            readonly const: "Error";
+        };
+        readonly result: {
+            readonly const: undefined;
+        };
+        readonly error: {
+            readonly type: "object";
+            readonly required: readonly ["httpStatus", "code"];
+            readonly properties: {
+                readonly httpStatus: {
+                    readonly enum: [HTTPStatus.Forbidden];
+                };
+                readonly code: {
+                    readonly enum: [ACError.OwnershipError, ACError.InsecureOperator, ACError.InvalidLimit];
+                };
+                readonly message: {
+                    readonly type: "string";
+                };
+                readonly details: {
+                    readonly type: "object";
+                    readonly variable: true;
+                };
+            };
+        };
+    };
+};
+export declare const countErrorSchema: () => {
+    readonly type: "object";
+    readonly properties: {
+        readonly _tag: {
+            readonly const: "Error";
+        };
+        readonly result: {
+            readonly const: undefined;
+        };
+        readonly error: {
+            readonly type: "object";
+            readonly required: readonly ["httpStatus", "code"];
+            readonly properties: {
+                readonly httpStatus: {
+                    readonly enum: [HTTPStatus.Forbidden];
+                };
+                readonly code: {
+                    readonly enum: [ACError.OwnershipError, ACError.InvalidLimit];
+                };
+                readonly message: {
+                    readonly type: "string";
+                };
+                readonly details: {
+                    readonly type: "object";
+                    readonly variable: true;
+                };
+            };
+        };
+    };
+};

package/dist/functionSchemas.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countErrorSchema = exports.getAllErrorSchema = exports.getErrorSchema = exports.insertErrorSchema = void 0;
+const accessControl_js_1 = require("./accessControl.js");
+const http_js_1 = require("./http.js");
+const resultSchemas_js_1 = require("./resultSchemas.js");
+const validation_js_1 = require("./validation.js");
+const insertErrorSchema = () => (0, resultSchemas_js_1.endpointErrorSchema)({
+    httpStatus: [
+        http_js_1.HTTPStatus.Forbidden,
+        http_js_1.HTTPStatus.NotFound,
+        http_js_1.HTTPStatus.UnprocessableContent,
+        http_js_1.HTTPStatus.BadRequest,
+    ],
+    code: [
+        accessControl_js_1.ACError.InsecureOperator,
+        accessControl_js_1.ACError.OwnershipError,
+        accessControl_js_1.ACError.ResourceNotFound,
+        accessControl_js_1.ACError.TargetImmutable,
+        accessControl_js_1.ACError.MalformedInput,
+        validation_js_1.ValidationErrorCode.EmptyTarget,
+        validation_js_1.ValidationErrorCode.InvalidProperties,
+        validation_js_1.ValidationErrorCode.MissingProperties,
+        validation_js_1.TraverseError.InvalidDocumentId,
+        validation_js_1.TraverseError.InvalidTempfile,
+    ],
+});
+exports.insertErrorSchema = insertErrorSchema;
+const getErrorSchema = () => (0, resultSchemas_js_1.endpointErrorSchema)({
+    httpStatus: [
+        http_js_1.HTTPStatus.Forbidden,
+        http_js_1.HTTPStatus.NotFound,
+        http_js_1.HTTPStatus.BadRequest,
+    ],
+    code: [
+        accessControl_js_1.ACError.ResourceNotFound,
+        accessControl_js_1.ACError.OwnershipError,
+        accessControl_js_1.ACError.InsecureOperator,
+        accessControl_js_1.ACError.MalformedInput,
+    ],
+});
+exports.getErrorSchema = getErrorSchema;
+const getAllErrorSchema = () => (0, resultSchemas_js_1.endpointErrorSchema)({
+    httpStatus: [http_js_1.HTTPStatus.Forbidden],
+    code: [
+        accessControl_js_1.ACError.OwnershipError,
+        accessControl_js_1.ACError.InsecureOperator,
+        accessControl_js_1.ACError.InvalidLimit,
+    ],
+});
+exports.getAllErrorSchema = getAllErrorSchema;
+const countErrorSchema = () => (0, resultSchemas_js_1.endpointErrorSchema)({
+    httpStatus: [http_js_1.HTTPStatus.Forbidden],
+    code: [
+        accessControl_js_1.ACError.OwnershipError,
+        accessControl_js_1.ACError.InvalidLimit,
+    ],
+});
+exports.countErrorSchema = countErrorSchema;

package/dist/functionSchemas.mjs

@@ -0,0 +1,53 @@
+"use strict";
+import { ACError } from "./accessControl.mjs";
+import { HTTPStatus } from "./http.mjs";
+import { endpointErrorSchema } from "./resultSchemas.mjs";
+import { ValidationErrorCode, TraverseError } from "./validation.mjs";
+export const insertErrorSchema = () => endpointErrorSchema({
+  httpStatus: [
+    HTTPStatus.Forbidden,
+    HTTPStatus.NotFound,
+    HTTPStatus.UnprocessableContent,
+    HTTPStatus.BadRequest
+  ],
+  code: [
+    ACError.InsecureOperator,
+    ACError.OwnershipError,
+    ACError.ResourceNotFound,
+    ACError.TargetImmutable,
+    ACError.MalformedInput,
+    ValidationErrorCode.EmptyTarget,
+    ValidationErrorCode.InvalidProperties,
+    ValidationErrorCode.MissingProperties,
+    TraverseError.InvalidDocumentId,
+    TraverseError.InvalidTempfile
+  ]
+});
+export const getErrorSchema = () => endpointErrorSchema({
+  httpStatus: [
+    HTTPStatus.Forbidden,
+    HTTPStatus.NotFound,
+    HTTPStatus.BadRequest
+  ],
+  code: [
+    ACError.ResourceNotFound,
+    ACError.OwnershipError,
+    ACError.InsecureOperator,
+    ACError.MalformedInput
+  ]
+});
+export const getAllErrorSchema = () => endpointErrorSchema({
+  httpStatus: [HTTPStatus.Forbidden],
+  code: [
+    ACError.OwnershipError,
+    ACError.InsecureOperator,
+    ACError.InvalidLimit
+  ]
+});
+export const countErrorSchema = () => endpointErrorSchema({
+  httpStatus: [HTTPStatus.Forbidden],
+  code: [
+    ACError.OwnershipError,
+    ACError.InvalidLimit
+  ]
+});

package/dist/functions.d.ts

@@ -1,11 +1,10 @@
 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 { SchemaWithId, PackReferences } from './schema.js';
+import type { SchemaWithId, InferSchema, 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';
+import type { WithACErrors } from './http.js';
+import type { countErrorSchema, getAllErrorSchema, getErrorSchema, insertErrorSchema } from './functionSchemas.js';
 export type UploadAuxProps = {
     parentId: string;
     propName: string;
@@ -70,10 +69,10 @@ export type RemoveFilePayload = UploadAuxProps & {
         _id: ObjectId | string;
     };
 };
-export type InsertReturnType<TDocument> = Result.Either<EndpointError<ACError.InsecureOperator | ACError.OwnershipError | ACError.ResourceNotFound | ACError.TargetImmutable | ACError.MalformedInput | ValidationErrorCode | TraverseError.InvalidDocumentId | TraverseError.InvalidTempfile, unknown, HTTPStatus.Forbidden | HTTPStatus.NotFound | HTTPStatus.UnprocessableContent | HTTPStatus.BadRequest>, TDocument>;
-export type GetReturnType<TDocument> = Result.Either<EndpointError<ACError.ResourceNotFound | ACError.OwnershipError | ACError.InsecureOperator | ACError.MalformedInput, unknown, HTTPStatus.Forbidden | HTTPStatus.NotFound | HTTPStatus.BadRequest>, TDocument>;
-export type GetAllReturnType<TDocument> = Result.Either<EndpointError<ACError.InvalidLimit | ACError.InsecureOperator | ACError.OwnershipError, unknown, HTTPStatus.Forbidden>, TDocument[]>;
-export type CountReturnType = Result.Either<EndpointError, number>;
+export type InsertReturnType<TDocument> = Result.Either<ExtractError<InferSchema<ReturnType<typeof insertErrorSchema>>>, TDocument>;
+export type GetReturnType<TDocument> = Result.Either<ExtractError<InferSchema<ReturnType<typeof getErrorSchema>>>, TDocument>;
+export type GetAllReturnType<TDocument> = Result.Either<ExtractError<InferSchema<ReturnType<typeof getAllErrorSchema>>>, TDocument[]>;
+export type CountReturnType = Result.Either<ExtractError<InferSchema<ReturnType<typeof countErrorSchema>>>, number>;
 export type RemoveReturnType<TDocument> = Result.Either<EndpointError, TDocument>;
 export type PaginatedGetAllReturnType<TDocument> = Result.Either<ExtractError<GetAllReturnType<TDocument>>, {
     data: TDocument[];

package/dist/index.d.ts

@@ -7,9 +7,11 @@ export * from './contract.js';
 export * from './description.js';
 export * from './endpointError.js';
 export * from './functions.js';
+export * from './functionSchemas.js';
 export * from './http.js';
 export * from './property.js';
 export * from './result.js';
+export * from './resultSchemas.js';
 export * from './schema.js';
 export * from './security.js';
 export * from './token.js';

package/dist/index.js

@@ -23,9 +23,11 @@ __exportStar(require("./contract.js"), exports);
 __exportStar(require("./description.js"), exports);
 __exportStar(require("./endpointError.js"), exports);
 __exportStar(require("./functions.js"), exports);
+__exportStar(require("./functionSchemas.js"), exports);
 __exportStar(require("./http.js"), exports);
 __exportStar(require("./property.js"), exports);
 __exportStar(require("./result.js"), exports);
+__exportStar(require("./resultSchemas.js"), exports);
 __exportStar(require("./schema.js"), exports);
 __exportStar(require("./security.js"), exports);
 __exportStar(require("./token.js"), exports);

package/dist/index.mjs

@@ -8,9 +8,11 @@ export * from "./contract.mjs";
 export * from "./description.mjs";
 export * from "./endpointError.mjs";
 export * from "./functions.mjs";
+export * from "./functionSchemas.mjs";
 export * from "./http.mjs";
 export * from "./property.mjs";
 export * from "./result.mjs";
+export * from "./resultSchemas.mjs";
 export * from "./schema.mjs";
 export * from "./security.mjs";
 export * from "./token.mjs";

package/dist/resultSchemas.d.ts

@@ -0,0 +1,89 @@
+import type { Property } from './property.js';
+import type { HTTPStatus } from './http.js';
+export declare const errorSchema: <const TObject extends Property>(object: TObject) => {
+    readonly type: "object";
+    readonly properties: {
+        readonly _tag: {
+            readonly const: "Error";
+        };
+        readonly error: Property;
+        readonly result: {
+            readonly const: undefined;
+        };
+    };
+};
+export declare const resultSchema: <const TObject extends Property>(object: TObject) => {
+    readonly type: "object";
+    readonly properties: {
+        readonly _tag: {
+            readonly const: "Result";
+        };
+        readonly error: {
+            readonly const: undefined;
+        };
+        readonly result: Property;
+    };
+};
+export declare const endpointErrorSchema: <const THTTPStatus extends HTTPStatus[], const TCode extends string[]>(error: {
+    httpStatus: THTTPStatus;
+    code: TCode;
+}) => {
+    readonly type: "object";
+    readonly properties: {
+        readonly _tag: {
+            readonly const: "Error";
+        };
+        readonly result: {
+            readonly const: undefined;
+        };
+        readonly error: {
+            readonly type: "object";
+            readonly required: readonly ["httpStatus", "code"];
+            readonly properties: {
+                readonly httpStatus: {
+                    readonly enum: THTTPStatus;
+                };
+                readonly code: {
+                    readonly enum: TCode;
+                };
+                readonly message: {
+                    readonly type: "string";
+                };
+                readonly details: {
+                    readonly type: "object";
+                    readonly variable: true;
+                };
+            };
+        };
+    };
+};
+export declare const genericEndpointErrorSchema: () => {
+    readonly type: "object";
+    readonly properties: {
+        readonly _tag: {
+            readonly const: "Error";
+        };
+        readonly result: {
+            readonly const: undefined;
+        };
+        readonly error: {
+            readonly type: "object";
+            readonly required: readonly ["httpStatus", "code"];
+            readonly properties: {
+                readonly httpStatus: {
+                    readonly type: "number";
+                };
+                readonly code: {
+                    readonly type: "string";
+                };
+                readonly message: {
+                    readonly type: "string";
+                };
+                readonly details: {
+                    readonly type: "object";
+                    readonly variable: true;
+                };
+            };
+        };
+    };
+};

package/dist/resultSchemas.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genericEndpointErrorSchema = exports.endpointErrorSchema = exports.resultSchema = exports.errorSchema = void 0;
+const errorSchema = (object) => {
+    return {
+        type: 'object',
+        properties: {
+            _tag: {
+                const: 'Error',
+            },
+            error: object,
+            result: {
+                const: undefined,
+            },
+        },
+    };
+};
+exports.errorSchema = errorSchema;
+const resultSchema = (object) => {
+    return {
+        type: 'object',
+        properties: {
+            _tag: {
+                const: 'Result',
+            },
+            error: {
+                const: undefined,
+            },
+            result: object,
+        },
+    };
+};
+exports.resultSchema = resultSchema;
+const endpointErrorSchema = (error) => {
+    return {
+        type: 'object',
+        properties: {
+            _tag: {
+                const: 'Error',
+            },
+            result: {
+                const: undefined,
+            },
+            error: {
+                type: 'object',
+                required: [
+                    'httpStatus',
+                    'code',
+                ],
+                properties: {
+                    httpStatus: {
+                        enum: error.httpStatus,
+                    },
+                    code: {
+                        enum: error.code,
+                    },
+                    message: {
+                        type: 'string',
+                    },
+                    details: {
+                        type: 'object',
+                        variable: true,
+                    },
+                },
+            },
+        },
+    };
+};
+exports.endpointErrorSchema = endpointErrorSchema;
+const genericEndpointErrorSchema = () => {
+    return {
+        type: 'object',
+        properties: {
+            _tag: {
+                const: 'Error',
+            },
+            result: {
+                const: undefined,
+            },
+            error: {
+                type: 'object',
+                required: [
+                    'httpStatus',
+                    'code',
+                ],
+                properties: {
+                    httpStatus: {
+                        type: 'number',
+                    },
+                    code: {
+                        type: 'string',
+                    },
+                    message: {
+                        type: 'string',
+                    },
+                    details: {
+                        type: 'object',
+                        variable: true,
+                    },
+                },
+            },
+        },
+    };
+};
+exports.genericEndpointErrorSchema = genericEndpointErrorSchema;

package/dist/resultSchemas.mjs

@@ -0,0 +1,99 @@
+"use strict";
+export const errorSchema = (object) => {
+  return {
+    type: "object",
+    properties: {
+      _tag: {
+        const: "Error"
+      },
+      error: object,
+      result: {
+        const: void 0
+      }
+    }
+  };
+};
+export const resultSchema = (object) => {
+  return {
+    type: "object",
+    properties: {
+      _tag: {
+        const: "Result"
+      },
+      error: {
+        const: void 0
+      },
+      result: object
+    }
+  };
+};
+export const endpointErrorSchema = (error) => {
+  return {
+    type: "object",
+    properties: {
+      _tag: {
+        const: "Error"
+      },
+      result: {
+        const: void 0
+      },
+      error: {
+        type: "object",
+        required: [
+          "httpStatus",
+          "code"
+        ],
+        properties: {
+          httpStatus: {
+            enum: error.httpStatus
+          },
+          code: {
+            enum: error.code
+          },
+          message: {
+            type: "string"
+          },
+          details: {
+            type: "object",
+            variable: true
+          }
+        }
+      }
+    }
+  };
+};
+export const genericEndpointErrorSchema = () => {
+  return {
+    type: "object",
+    properties: {
+      _tag: {
+        const: "Error"
+      },
+      result: {
+        const: void 0
+      },
+      error: {
+        type: "object",
+        required: [
+          "httpStatus",
+          "code"
+        ],
+        properties: {
+          httpStatus: {
+            type: "number"
+          },
+          code: {
+            type: "string"
+          },
+          message: {
+            type: "string"
+          },
+          details: {
+            type: "object",
+            variable: true
+          }
+        }
+      }
+    }
+  };
+};

package/dist/token.d.ts

@@ -6,9 +6,9 @@ export type UserRole = (Collections['user']['item'] extends {
 export type AcceptedRole = UserRole | UserRole[] | null | unknown;
 export type AuthenticatedToken<TAcceptedRole extends AcceptedRole = null, TUserRole = UserRole, TUserInfo = Omit<Collections['user']['item'], '_id' | 'roles'>> = {
     authenticated: true;
-    sub: ObjectId;
+    sub: ObjectId | null;
     roles: readonly (TAcceptedRole extends null ? TUserRole : TAcceptedRole)[];
-    userinfo: TUserInfo | PackReferences<TUserInfo>;
+    userinfo: Partial<TUserInfo | PackReferences<TUserInfo>>;
 };
 export type UnauthenticatedToken = {
     authenticated: false;

package/package.json

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