@aeriajs/builtins 0.0.255 → 0.0.257

package/dist/collections/user/index.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.user = void 0;
 const core_1 = require("@aeriajs/core");
-const types_1 = require("@aeriajs/types");
 const description_js_1 = require("./description.js");
 const authenticate_js_1 = require("./authenticate.js");
 const activate_js_1 = require("./activate.js");
@@ -61,25 +60,14 @@ exports.user = (0, core_1.defineCollection)({
 Object.assign(exports.user, {
     exposedFunctions,
     contracts: {
-        editProfile: {
-            payload: {
-                type: 'object',
-                required: [],
-                properties: description_js_1.description.properties,
-            },
-            response: [
-                types_1.functionSchemas.insertError(),
-                (0, types_1.resultSchema)({
-                    $ref: 'user',
-                }),
-            ],
-        },
-        getCurrentUser: {
-            response: [
-                (0, types_1.resultSchema)({
-                    $ref: 'user',
-                }),
-            ],
-        },
+        activate: activate_js_1.activateContract,
+        authenticate: authenticate_js_1.authenticateContract,
+        createAccount: createAccount_js_1.createAccountContract,
+        editProfile: editProfile_js_1.editProfileContract,
+        getActivationLink: getActivationLink_js_1.getActivationLinkContract,
+        getCurrentUser: getCurrentUser_js_1.getCurrentUserContract,
+        getInfo: getInfo_js_1.getInfoContract,
+        getRedefinePasswordLink: getRedefinePasswordLink_js_1.getRedefinePasswordLinkContract,
+        redefinePassword: redefinePassword_js_1.redefinePasswordContract,
     },
 });

package/dist/collections/user/index.mjs

@@ -1,17 +1,16 @@
 "use strict";
 import { defineCollection, get, getAll, remove, upload, removeFile } from "@aeriajs/core";
-import { functionSchemas, resultSchema } from "@aeriajs/types";
 import { description } from "./description.mjs";
-import { authenticate } from "./authenticate.mjs";
-import { activate } from "./activate.mjs";
+import { authenticate, authenticateContract } from "./authenticate.mjs";
+import { activate, activateContract } from "./activate.mjs";
 import { insert } from "./insert.mjs";
-import { createAccount } from "./createAccount.mjs";
-import { getInfo } from "./getInfo.mjs";
-import { getCurrentUser } from "./getCurrentUser.mjs";
-import { getActivationLink } from "./getActivationLink.mjs";
-import { redefinePassword } from "./redefinePassword.mjs";
-import { getRedefinePasswordLink } from "./getRedefinePasswordLink.mjs";
-import { editProfile } from "./editProfile.mjs";
+import { createAccount, createAccountContract } from "./createAccount.mjs";
+import { getInfo, getInfoContract } from "./getInfo.mjs";
+import { getCurrentUser, getCurrentUserContract } from "./getCurrentUser.mjs";
+import { getActivationLink, getActivationLinkContract } from "./getActivationLink.mjs";
+import { redefinePassword, redefinePasswordContract } from "./redefinePassword.mjs";
+import { getRedefinePasswordLink, getRedefinePasswordLinkContract } from "./getRedefinePasswordLink.mjs";
+import { editProfile, editProfileContract } from "./editProfile.mjs";
 const functions = {
   get,
   getAll,
@@ -59,25 +58,14 @@ export const user = defineCollection({
 Object.assign(user, {
   exposedFunctions,
   contracts: {
-    editProfile: {
-      payload: {
-        type: "object",
-        required: [],
-        properties: description.properties
-      },
-      response: [
-        functionSchemas.insertError(),
-        resultSchema({
-          $ref: "user"
-        })
-      ]
-    },
-    getCurrentUser: {
-      response: [
-        resultSchema({
-          $ref: "user"
-        })
-      ]
-    }
+    activate: activateContract,
+    authenticate: authenticateContract,
+    createAccount: createAccountContract,
+    editProfile: editProfileContract,
+    getActivationLink: getActivationLinkContract,
+    getCurrentUser: getCurrentUserContract,
+    getInfo: getInfoContract,
+    getRedefinePasswordLink: getRedefinePasswordLinkContract,
+    redefinePassword: redefinePasswordContract
   }
 });

package/dist/collections/user/redefinePassword.d.ts

@@ -1,41 +1,100 @@
-import type { Context } from '@aeriajs/types';
+import type { Context, ContractToFunction } from '@aeriajs/types';
 import type { description } from './description.js';
-import { ObjectId } from '@aeriajs/core';
-import { Result } from '@aeriajs/types';
-export declare const ActivationError: {
+export declare const RedefinePasswordError: {
     readonly UserNotFound: "USER_NOT_FOUND";
     readonly UserNotActive: "USER_NOT_ACTIVE";
     readonly InvalidLink: "INVALID_LINK";
     readonly InvalidToken: "INVALID_TOKEN";
 };
-export declare const redefinePassword: (payload: {
-    password?: string;
-    userId?: string;
-    token?: string;
-}, context: Context<typeof description>) => Promise<Result.Error<{
-    readonly code: "INVALID_LINK";
-} & {
-    httpStatus: 404;
-}> | Result.Error<{
-    readonly code: "USER_NOT_FOUND";
-} & {
-    httpStatus: 404;
-}> | Result.Error<{
-    readonly code: "USER_NOT_ACTIVE";
-} & {
-    httpStatus: 403;
-}> | Result.Error<{
-    readonly code: "INVALID_TOKEN";
-} & {
-    httpStatus: 401;
-}> | Result.Error<{
-    readonly code: "MALFORMED_INPUT";
-} & {
-    httpStatus: 422;
-}> | {
-    readonly _tag: "Result";
-    readonly error: undefined;
-    readonly result: {
-        readonly userId: ObjectId;
+export declare const redefinePasswordContract: {
+    readonly payload: {
+        readonly type: "object";
+        readonly required: readonly [];
+        readonly properties: {
+            readonly userId: {
+                readonly type: "string";
+                readonly format: "objectid";
+            };
+            readonly password: {
+                readonly type: "string";
+            };
+            readonly token: {
+                readonly type: "string";
+            };
+        };
     };
-}>;
+    readonly response: [{
+        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: [403, 404, 400];
+                    };
+                    readonly code: {
+                        readonly enum: ["RESOURCE_NOT_FOUND", "OWNERSHIP_ERROR", "INSECURE_OPERATOR", "MALFORMED_INPUT"];
+                    };
+                    readonly message: {
+                        readonly type: "string";
+                    };
+                    readonly details: {
+                        readonly type: "object";
+                        readonly additionalProperties: true;
+                    };
+                };
+            };
+        };
+    }, {
+        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: [404, 403, 401, 422];
+                    };
+                    readonly code: {
+                        readonly enum: ["MALFORMED_INPUT", "INVALID_LINK", "INVALID_TOKEN", "USER_NOT_FOUND", "USER_NOT_ACTIVE"];
+                    };
+                    readonly message: {
+                        readonly type: "string";
+                    };
+                    readonly details: {
+                        readonly type: "object";
+                        readonly additionalProperties: true;
+                    };
+                };
+            };
+        };
+    }, {
+        readonly type: "object";
+        readonly properties: {
+            readonly _tag: {
+                readonly const: "Result";
+            };
+            readonly error: {
+                readonly const: undefined;
+            };
+            readonly result: {
+                readonly type: "object";
+                readonly properties: {};
+            };
+        };
+    }];
+};
+export declare const redefinePassword: ContractToFunction<typeof redefinePasswordContract, Context<typeof description>>;

package/dist/collections/user/redefinePassword.js

@@ -1,15 +1,55 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.redefinePassword = exports.ActivationError = void 0;
+exports.redefinePassword = exports.redefinePasswordContract = exports.RedefinePasswordError = void 0;
 const core_1 = require("@aeriajs/core");
 const types_1 = require("@aeriajs/types");
 const bcrypt = require("bcryptjs");
-exports.ActivationError = {
+exports.RedefinePasswordError = {
     UserNotFound: 'USER_NOT_FOUND',
     UserNotActive: 'USER_NOT_ACTIVE',
     InvalidLink: 'INVALID_LINK',
     InvalidToken: 'INVALID_TOKEN',
 };
+exports.redefinePasswordContract = (0, types_1.defineContract)({
+    payload: {
+        type: 'object',
+        required: [],
+        properties: {
+            userId: {
+                type: 'string',
+                format: 'objectid',
+            },
+            password: {
+                type: 'string',
+            },
+            token: {
+                type: 'string',
+            },
+        },
+    },
+    response: [
+        types_1.functionSchemas.getError(),
+        (0, types_1.endpointErrorSchema)({
+            httpStatus: [
+                types_1.HTTPStatus.NotFound,
+                types_1.HTTPStatus.Forbidden,
+                types_1.HTTPStatus.Unauthorized,
+                types_1.HTTPStatus.UnprocessableContent,
+            ],
+            code: [
+                types_1.ACError.MalformedInput,
+                exports.RedefinePasswordError.InvalidLink,
+                exports.RedefinePasswordError.InvalidToken,
+                exports.RedefinePasswordError.UserNotFound,
+                exports.RedefinePasswordError.UserNotActive,
+            ],
+        }),
+        (0, types_1.resultSchema)({
+            type: 'object',
+            properties: {},
+        }),
+    ],
+});
 const redefinePassword = async (payload, context) => {
     const { userId, token, password, } = payload;
     if (!context.config.secret) {
@@ -17,7 +57,7 @@ const redefinePassword = async (payload, context) => {
     }
     if (!userId || !token) {
         return context.error(types_1.HTTPStatus.NotFound, {
-            code: exports.ActivationError.InvalidLink,
+            code: exports.RedefinePasswordError.InvalidLink,
         });
     }
     const user = await context.collection.model.findOne({
@@ -30,18 +70,18 @@ const redefinePassword = async (payload, context) => {
     });
     if (!user) {
         return context.error(types_1.HTTPStatus.NotFound, {
-            code: exports.ActivationError.UserNotFound,
+            code: exports.RedefinePasswordError.UserNotFound,
         });
     }
     if (!user.active) {
         return context.error(types_1.HTTPStatus.Forbidden, {
-            code: exports.ActivationError.UserNotActive,
+            code: exports.RedefinePasswordError.UserNotActive,
         });
     }
     const decoded = await (0, core_1.decodeToken)(token, context.config.secret);
     if (!decoded) {
         return context.error(types_1.HTTPStatus.Unauthorized, {
-            code: exports.ActivationError.InvalidToken,
+            code: exports.RedefinePasswordError.InvalidToken,
         });
     }
     if (!password) {

package/dist/collections/user/redefinePassword.mjs

@@ -1,13 +1,53 @@
 "use strict";
 import { decodeToken, ObjectId } from "@aeriajs/core";
-import { Result, ACError, HTTPStatus } from "@aeriajs/types";
+import { Result, ACError, HTTPStatus, resultSchema, functionSchemas, endpointErrorSchema, defineContract } from "@aeriajs/types";
 import * as bcrypt from "bcryptjs";
-export const ActivationError = {
+export const RedefinePasswordError = {
   UserNotFound: "USER_NOT_FOUND",
   UserNotActive: "USER_NOT_ACTIVE",
   InvalidLink: "INVALID_LINK",
   InvalidToken: "INVALID_TOKEN"
 };
+export const redefinePasswordContract = defineContract({
+  payload: {
+    type: "object",
+    required: [],
+    properties: {
+      userId: {
+        type: "string",
+        format: "objectid"
+      },
+      password: {
+        type: "string"
+      },
+      token: {
+        type: "string"
+      }
+    }
+  },
+  response: [
+    functionSchemas.getError(),
+    endpointErrorSchema({
+      httpStatus: [
+        HTTPStatus.NotFound,
+        HTTPStatus.Forbidden,
+        HTTPStatus.Unauthorized,
+        HTTPStatus.UnprocessableContent
+      ],
+      code: [
+        ACError.MalformedInput,
+        RedefinePasswordError.InvalidLink,
+        RedefinePasswordError.InvalidToken,
+        RedefinePasswordError.UserNotFound,
+        RedefinePasswordError.UserNotActive
+      ]
+    }),
+    resultSchema({
+      type: "object",
+      properties: {}
+    })
+  ]
+});
 export const redefinePassword = async (payload, context) => {
   const {
     userId,
@@ -19,7 +59,7 @@ export const redefinePassword = async (payload, context) => {
   }
   if (!userId || !token) {
     return context.error(HTTPStatus.NotFound, {
-      code: ActivationError.InvalidLink
+      code: RedefinePasswordError.InvalidLink
     });
   }
   const user = await context.collection.model.findOne({
@@ -32,18 +72,18 @@ export const redefinePassword = async (payload, context) => {
   });
   if (!user) {
     return context.error(HTTPStatus.NotFound, {
-      code: ActivationError.UserNotFound
+      code: RedefinePasswordError.UserNotFound
     });
   }
   if (!user.active) {
     return context.error(HTTPStatus.Forbidden, {
-      code: ActivationError.UserNotActive
+      code: RedefinePasswordError.UserNotActive
     });
   }
   const decoded = await decodeToken(token, context.config.secret);
   if (!decoded) {
     return context.error(HTTPStatus.Unauthorized, {
-      code: ActivationError.InvalidToken
+      code: RedefinePasswordError.InvalidToken
     });
   }
   if (!password) {

package/dist/functions/describe.d.ts

@@ -22,8 +22,8 @@ declare const Payload: Partial<{} & Omit<Readonly<import("@aeriajs/types").Filte
     };
 }>> & {
     roles: boolean;
-    collections: string[];
     revalidate: boolean;
+    collections: string[];
     noSerialize: boolean;
     router: boolean;
 }, never>>;
@@ -37,19 +37,45 @@ export declare const describe: (contextOrPayload: RouteContext | typeof Payload)
     readonly result: undefined;
 } | {
     readonly _tag: "Error";
-    readonly error: ({
-        readonly code: "AUTHORIZATION_ERROR";
-    } & {
-        httpStatus: 401;
-    }) | ({
-        readonly code: "INVALID_CREDENTIALS";
-    } & {
+    readonly error: Pick<{} & Omit<Readonly<import("@aeriajs/types").FilterReadonlyProperties<{
+        readonly httpStatus: {
+            readonly enum: [401];
+        };
+        readonly code: {
+            readonly enum: ["AUTHORIZATION_ERROR", "INVALID_CREDENTIALS", "INACTIVE_USER"];
+        };
+        readonly message: {
+            readonly type: "string";
+        };
+        readonly details: {
+            readonly type: "object";
+            readonly additionalProperties: true;
+        };
+    }>> & {
+        code: "AUTHORIZATION_ERROR" | "INVALID_CREDENTIALS" | "INACTIVE_USER";
         httpStatus: 401;
-    }) | ({
-        readonly code: "INACTIVE_USER";
-    } & {
+        message: string;
+        details: any;
+    }, never>, "code" | "httpStatus"> & Partial<{} & Omit<Readonly<import("@aeriajs/types").FilterReadonlyProperties<{
+        readonly httpStatus: {
+            readonly enum: [401];
+        };
+        readonly code: {
+            readonly enum: ["AUTHORIZATION_ERROR", "INVALID_CREDENTIALS", "INACTIVE_USER"];
+        };
+        readonly message: {
+            readonly type: "string";
+        };
+        readonly details: {
+            readonly type: "object";
+            readonly additionalProperties: true;
+        };
+    }>> & {
+        code: "AUTHORIZATION_ERROR" | "INVALID_CREDENTIALS" | "INACTIVE_USER";
         httpStatus: 401;
-    });
+        message: string;
+        details: any;
+    }, never>>;
     readonly result: undefined;
 } | {
     readonly _tag: "Result";