@aeriajs/types 0.0.98 → 0.0.100

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 insertError: () => {
+    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 getError: () => {
+    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 getAllError: () => {
+    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 countError: () => {
+    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.countError = exports.getAllError = exports.getError = exports.insertError = 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 insertError = () => (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.insertError = insertError;
+const getError = () => (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.getError = getError;
+const getAllError = () => (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.getAllError = getAllError;
+const countError = () => (0, resultSchemas_js_1.endpointErrorSchema)({
+    httpStatus: [http_js_1.HTTPStatus.Forbidden],
+    code: [
+        accessControl_js_1.ACError.OwnershipError,
+        accessControl_js_1.ACError.InvalidLimit,
+    ],
+});
+exports.countError = countError;

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 insertError = () => 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 getError = () => endpointErrorSchema({
+  httpStatus: [
+    HTTPStatus.Forbidden,
+    HTTPStatus.NotFound,
+    HTTPStatus.BadRequest
+  ],
+  code: [
+    ACError.ResourceNotFound,
+    ACError.OwnershipError,
+    ACError.InsecureOperator,
+    ACError.MalformedInput
+  ]
+});
+export const getAllError = () => endpointErrorSchema({
+  httpStatus: [HTTPStatus.Forbidden],
+  code: [
+    ACError.OwnershipError,
+    ACError.InsecureOperator,
+    ACError.InvalidLimit
+  ]
+});
+export const countError = () => 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 * as functionSchemas 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 functionSchemas.insertError>>>, TDocument>;
+export type GetReturnType<TDocument> = Result.Either<ExtractError<InferSchema<ReturnType<typeof functionSchemas.getError>>>, TDocument>;
+export type GetAllReturnType<TDocument> = Result.Either<ExtractError<InferSchema<ReturnType<typeof functionSchemas.getAllError>>>, TDocument[]>;
+export type CountReturnType = Result.Either<ExtractError<InferSchema<ReturnType<typeof functionSchemas.countError>>>, 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

@@ -1,3 +1,4 @@
+export * as functionSchemas from './functionSchemas.js';
 export * from './accessControl.js';
 export * from './collection.js';
 export * from './condition.js';
@@ -10,6 +11,7 @@ export * from './functions.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

@@ -14,6 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.functionSchemas = void 0;
+exports.functionSchemas = require("./functionSchemas.js");
 __exportStar(require("./accessControl.js"), exports);
 __exportStar(require("./collection.js"), exports);
 __exportStar(require("./condition.js"), exports);
@@ -26,6 +28,7 @@ __exportStar(require("./functions.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

@@ -1,4 +1,5 @@
 "use strict";
+export * as functionSchemas from "./functionSchemas.mjs";
 export * from "./accessControl.mjs";
 export * from "./collection.mjs";
 export * from "./condition.mjs";
@@ -11,6 +12,7 @@ export * from "./functions.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 TError extends Property>(error: TError) => {
+    readonly type: "object";
+    readonly properties: {
+        readonly _tag: {
+            readonly const: "Error";
+        };
+        readonly error: Property;
+        readonly result: {
+            readonly const: undefined;
+        };
+    };
+};
+export declare const resultSchema: <const TResult extends Property>(result: TResult) => {
+    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 = (error) => {
+    return {
+        type: 'object',
+        properties: {
+            _tag: {
+                const: 'Error',
+            },
+            error,
+            result: {
+                const: undefined,
+            },
+        },
+    };
+};
+exports.errorSchema = errorSchema;
+const resultSchema = (result) => {
+    return {
+        type: 'object',
+        properties: {
+            _tag: {
+                const: 'Result',
+            },
+            error: {
+                const: undefined,
+            },
+            result,
+        },
+    };
+};
+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 = (error) => {
+  return {
+    type: "object",
+    properties: {
+      _tag: {
+        const: "Error"
+      },
+      error,
+      result: {
+        const: void 0
+      }
+    }
+  };
+};
+export const resultSchema = (result) => {
+  return {
+    type: "object",
+    properties: {
+      _tag: {
+        const: "Result"
+      },
+      error: {
+        const: void 0
+      },
+      result
+    }
+  };
+};
+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/package.json

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