payload 2.11.2 → 3.0.0-alpha.2

package/dist/index.js

@@ -9,32 +9,262 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    Payload: function() {
-        return Payload;
+    BasePayload: function() {
+        return BasePayload;
     },
     default: function() {
         return _default;
     },
     getPayload: function() {
-        return _payload.getPayload;
+        return getPayload;
     }
 });
-const _initHTTP = require("./initHTTP");
-const _payload = require("./payload");
-require('isomorphic-fetch');
-class Payload extends _payload.BasePayload {
+const _crypto = /*#__PURE__*/ _interop_require_default(require("crypto"));
+const _crypto1 = require("./auth/crypto");
+const _apiKey = require("./auth/strategies/apiKey");
+const _jwt = require("./auth/strategies/jwt");
+const _local = /*#__PURE__*/ _interop_require_default(require("./collections/operations/local"));
+const _build = /*#__PURE__*/ _interop_require_default(require("./email/build"));
+const _defaults = require("./email/defaults");
+const _sendEmail = /*#__PURE__*/ _interop_require_default(require("./email/sendEmail"));
+const _local1 = /*#__PURE__*/ _interop_require_default(require("./globals/operations/local"));
+const _logger = /*#__PURE__*/ _interop_require_default(require("./utilities/logger"));
+const _serverInit = require("./utilities/telemetry/events/serverInit");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class BasePayload {
+    authStrategies;
+    collections = {};
+    config;
+    /**
+   * @description Performs create operation
+   * @param options
+   * @returns created document
+   */ create = async (options)=>{
+        const { create } = _local.default;
+        return create(this, options);
+    };
+    db;
+    decrypt = _crypto1.decrypt;
+    email;
+    emailOptions;
+    encrypt = _crypto1.encrypt;
+    // TODO: re-implement or remove?
+    // errorHandler: ErrorHandler
+    extensions;
+    /**
+   * @description Find documents with criteria
+   * @param options
+   * @returns documents satisfying query
+   */ find = async (options)=>{
+        const { find } = _local.default;
+        return find(this, options);
+    };
+    findByID = async (options)=>{
+        const { findByID } = _local.default;
+        return findByID(this, options);
+    };
+    findGlobal = async (options)=>{
+        const { findOne } = _local1.default;
+        return findOne(this, options);
+    };
+    /**
+   * @description Find global version by ID
+   * @param options
+   * @returns global version with specified ID
+   */ findGlobalVersionByID = async (options)=>{
+        const { findVersionByID } = _local1.default;
+        return findVersionByID(this, options);
+    };
+    /**
+   * @description Find global versions with criteria
+   * @param options
+   * @returns versions satisfying query
+   */ findGlobalVersions = async (options)=>{
+        const { findVersions } = _local1.default;
+        return findVersions(this, options);
+    };
+    /**
+   * @description Find version by ID
+   * @param options
+   * @returns version with specified ID
+   */ findVersionByID = async (options)=>{
+        const { findVersionByID } = _local.default;
+        return findVersionByID(this, options);
+    };
+    /**
+   * @description Find versions with criteria
+   * @param options
+   * @returns versions satisfying query
+   */ findVersions = async (options)=>{
+        const { findVersions } = _local.default;
+        return findVersions(this, options);
+    };
+    forgotPassword = async (options)=>{
+        const { forgotPassword } = _local.default.auth;
+        return forgotPassword(this, options);
+    };
+    getAPIURL = ()=>`${this.config.serverURL}${this.config.routes.api}`;
+    getAdminURL = ()=>`${this.config.serverURL}${this.config.routes.admin}`;
+    globals;
+    logger;
+    login = async (options)=>{
+        const { login } = _local.default.auth;
+        return login(this, options);
+    };
+    /**
+   * @description Find document by ID
+   * @param options
+   * @returns document with specified ID
+   */ resetPassword = async (options)=>{
+        const { resetPassword } = _local.default.auth;
+        return resetPassword(this, options);
+    };
+    /**
+   * @description Restore global version by ID
+   * @param options
+   * @returns version with specified ID
+   */ restoreGlobalVersion = async (options)=>{
+        const { restoreVersion } = _local1.default;
+        return restoreVersion(this, options);
+    };
+    /**
+   * @description Restore version by ID
+   * @param options
+   * @returns version with specified ID
+   */ restoreVersion = async (options)=>{
+        const { restoreVersion } = _local.default;
+        return restoreVersion(this, options);
+    };
+    schema;
+    secret;
+    sendEmail;
+    types;
+    unlock = async (options)=>{
+        const { unlock } = _local.default.auth;
+        return unlock(this, options);
+    };
+    updateGlobal = async (options)=>{
+        const { update } = _local1.default;
+        return update(this, options);
+    };
+    validationRules;
+    verifyEmail = async (options)=>{
+        const { verifyEmail } = _local.default.auth;
+        return verifyEmail(this, options);
+    };
+    versions = {};
+    delete(options) {
+        const { deleteLocal } = _local.default;
+        return deleteLocal(this, options);
+    }
+    /**
+   * @description Initializes Payload
+   * @param options
+   */ // @ts-expect-error // TODO: TypeScript hallucinating again. fix later
     async init(options) {
-        const payload = await (0, _initHTTP.initHTTP)(options);
-        Object.assign(this, payload);
+        this.logger = (0, _logger.default)('payload', options.loggerOptions, options.loggerDestination);
+        this.config = await options.config;
+        if (!this.config.secret) {
+            throw new Error('Error: missing secret key. A secret key is needed to secure Payload.');
+        }
+        this.secret = _crypto.default.createHash('sha256').update(this.config.secret).digest('hex').slice(0, 32);
+        this.globals = {
+            config: this.config.globals
+        };
+        this.config.collections.forEach((collection)=>{
+            this.collections[collection.slug] = {
+                config: collection
+            };
+        });
+        this.db = this.config.db.init({
+            payload: this
+        });
+        this.db.payload = this;
+        if (this.db?.init) {
+            await this.db.init(this);
+        }
+        if (!options.disableDBConnect && this.db.connect) {
+            await this.db.connect(this);
+        }
+        this.logger.info('Starting Payload...');
+        // Configure email service
+        const emailOptions = options.email ? {
+            ...options.email
+        } : this.config.email;
+        if (options.email && this.config.email) {
+            this.logger.warn('Email options provided in both init options and config. Using init options.');
+        }
+        this.emailOptions = emailOptions ?? _defaults.defaults;
+        this.email = (0, _build.default)(this.emailOptions, this.logger);
+        this.sendEmail = _sendEmail.default.bind(this);
+        (0, _serverInit.serverInit)(this);
+        // 1. loop over collections, if collection has auth strategy, initialize and push to array
+        let jwtStrategyEnabled = false;
+        this.authStrategies = this.config.collections.reduce((authStrategies, collection)=>{
+            if (collection?.auth) {
+                if (collection.auth.strategies.length > 0) {
+                    authStrategies.push(...collection.auth.strategies);
+                }
+                // 2. if api key enabled, push api key strategy into the array
+                if (collection.auth?.useAPIKey) {
+                    authStrategies.push({
+                        name: `${collection.slug}-api-key`,
+                        authenticate: (0, _apiKey.APIKeyAuthentication)(collection)
+                    });
+                }
+                // 3. if localStrategy flag is true
+                if (!collection.auth.disableLocalStrategy && !jwtStrategyEnabled) {
+                    jwtStrategyEnabled = true;
+                }
+            }
+            return authStrategies;
+        }, []);
+        // 4. if enabled, push jwt strategy into authStrategies last
+        if (jwtStrategyEnabled) {
+            this.authStrategies.push({
+                name: 'local-jwt',
+                authenticate: _jwt.JWTAuthentication
+            });
+        }
         if (!options.disableOnInit) {
             if (typeof options.onInit === 'function') await options.onInit(this);
             if (typeof this.config.onInit === 'function') await this.config.onInit(this);
         }
-        return payload;
+        return this;
+    }
+    update(options) {
+        const { update } = _local.default;
+        return update(this, options);
     }
 }
-const payload = new Payload();
-const _default = payload;
-module.exports = payload;
+const initialized = new BasePayload();
+const _default = initialized;
+let cached = global._payload;
+if (!cached) {
+    // eslint-disable-next-line no-multi-assign
+    cached = global._payload = {
+        payload: null,
+        promise: null
+    };
+}
+const getPayload = async (options)=>{
+    if (cached.payload) {
+        return cached.payload;
+    }
+    if (!cached.promise) {
+        cached.promise = new BasePayload().init(options);
+    }
+    try {
+        cached.payload = await cached.promise;
+    } catch (e) {
+        cached.promise = null;
+        throw e;
+    }
+    return cached.payload;
+};
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import type { ExecutionResult, GraphQLSchema, ValidationRule } from 'graphql'\nimport type { OperationArgs, Request as graphQLRequest } from 'graphql-http'\nimport type { SendMailOptions } from 'nodemailer'\nimport type pino from 'pino'\n\nimport crypto from 'crypto'\n\nimport type { AuthStrategy } from './auth'\nimport type { Result as ForgotPasswordResult } from './auth/operations/forgotPassword'\nimport type { Options as ForgotPasswordOptions } from './auth/operations/local/forgotPassword'\nimport type { Options as LoginOptions } from './auth/operations/local/login'\nimport type { Options as ResetPasswordOptions } from './auth/operations/local/resetPassword'\nimport type { Options as UnlockOptions } from './auth/operations/local/unlock'\nimport type { Options as VerifyEmailOptions } from './auth/operations/local/verifyEmail'\nimport type { Result as LoginResult } from './auth/operations/login'\nimport type { Result as ResetPasswordResult } from './auth/operations/resetPassword'\nimport type { BulkOperationResult, Collection, TypeWithID } from './collections/config/types'\nimport type { Options as CreateOptions } from './collections/operations/local/create'\nimport type {\n  ByIDOptions as DeleteByIDOptions,\n  ManyOptions as DeleteManyOptions,\n  Options as DeleteOptions,\n} from './collections/operations/local/delete'\nimport type { Options as FindOptions } from './collections/operations/local/find'\nimport type { Options as FindByIDOptions } from './collections/operations/local/findByID'\nimport type { Options as FindVersionByIDOptions } from './collections/operations/local/findVersionByID'\nimport type { Options as FindVersionsOptions } from './collections/operations/local/findVersions'\nimport type { Options as RestoreVersionOptions } from './collections/operations/local/restoreVersion'\nimport type {\n  ByIDOptions as UpdateByIDOptions,\n  ManyOptions as UpdateManyOptions,\n  Options as UpdateOptions,\n} from './collections/operations/local/update'\nimport type { EmailOptions, InitOptions, SanitizedConfig } from './config/types'\nimport type { BaseDatabaseAdapter, PaginatedDocs } from './database/types'\nimport type { BuildEmailResult } from './email/types'\nimport type { TypeWithID as GlobalTypeWithID, Globals } from './globals/config/types'\nimport type { Options as FindGlobalOptions } from './globals/operations/local/findOne'\nimport type { Options as FindGlobalVersionByIDOptions } from './globals/operations/local/findVersionByID'\nimport type { Options as FindGlobalVersionsOptions } from './globals/operations/local/findVersions'\nimport type { Options as RestoreGlobalVersionOptions } from './globals/operations/local/restoreVersion'\nimport type { Options as UpdateGlobalOptions } from './globals/operations/local/update'\nimport type { TypeWithVersion } from './versions/types'\n\nimport { decrypt, encrypt } from './auth/crypto'\nimport { APIKeyAuthentication } from './auth/strategies/apiKey'\nimport { JWTAuthentication } from './auth/strategies/jwt'\nimport localOperations from './collections/operations/local'\nimport buildEmail from './email/build'\nimport { defaults as emailDefaults } from './email/defaults'\nimport sendEmail from './email/sendEmail'\nimport localGlobalOperations from './globals/operations/local'\nimport Logger from './utilities/logger'\nimport { serverInit as serverInitTelemetry } from './utilities/telemetry/events/serverInit'\n\n/**\n * @description Payload\n */\nexport class BasePayload<TGeneratedTypes extends GeneratedTypes> {\n  authStrategies: AuthStrategy[]\n\n  collections: {\n    [slug: number | string | symbol]: Collection\n  } = {}\n\n  config: SanitizedConfig\n\n  /**\n   * @description Performs create operation\n   * @param options\n   * @returns created document\n   */\n  create = async <T extends keyof TGeneratedTypes['collections']>(\n    options: CreateOptions<T>,\n  ): Promise<TGeneratedTypes['collections'][T]> => {\n    const { create } = localOperations\n    return create<T>(this, options)\n  }\n\n  db: BaseDatabaseAdapter\n\n  decrypt = decrypt\n\n  email: BuildEmailResult\n\n  emailOptions: EmailOptions\n\n  encrypt = encrypt\n\n  // TODO: re-implement or remove?\n  // errorHandler: ErrorHandler\n\n  extensions: (args: {\n    args: OperationArgs<any>\n    req: graphQLRequest<unknown, unknown>\n    result: ExecutionResult\n  }) => Promise<any>\n\n  /**\n   * @description Find documents with criteria\n   * @param options\n   * @returns documents satisfying query\n   */\n  find = async <T extends keyof TGeneratedTypes['collections']>(\n    options: FindOptions<T>,\n  ): Promise<PaginatedDocs<TGeneratedTypes['collections'][T]>> => {\n    const { find } = localOperations\n    return find<T>(this, options)\n  }\n\n  findByID = async <T extends keyof TGeneratedTypes['collections']>(\n    options: FindByIDOptions<T>,\n  ): Promise<TGeneratedTypes['collections'][T]> => {\n    const { findByID } = localOperations\n    return findByID<T>(this, options)\n  }\n\n  findGlobal = async <T extends keyof TGeneratedTypes['globals']>(\n    options: FindGlobalOptions<T>,\n  ): Promise<TGeneratedTypes['globals'][T]> => {\n    const { findOne } = localGlobalOperations\n    return findOne<T>(this, options)\n  }\n\n  /**\n   * @description Find global version by ID\n   * @param options\n   * @returns global version with specified ID\n   */\n  findGlobalVersionByID = async <T extends keyof TGeneratedTypes['globals']>(\n    options: FindGlobalVersionByIDOptions<T>,\n  ): Promise<TypeWithVersion<TGeneratedTypes['globals'][T]>> => {\n    const { findVersionByID } = localGlobalOperations\n    return findVersionByID<T>(this, options)\n  }\n\n  /**\n   * @description Find global versions with criteria\n   * @param options\n   * @returns versions satisfying query\n   */\n  findGlobalVersions = async <T extends keyof TGeneratedTypes['globals']>(\n    options: FindGlobalVersionsOptions<T>,\n  ): Promise<PaginatedDocs<TypeWithVersion<TGeneratedTypes['globals'][T]>>> => {\n    const { findVersions } = localGlobalOperations\n    return findVersions<T>(this, options)\n  }\n\n  /**\n   * @description Find version by ID\n   * @param options\n   * @returns version with specified ID\n   */\n  findVersionByID = async <T extends keyof TGeneratedTypes['collections']>(\n    options: FindVersionByIDOptions<T>,\n  ): Promise<TypeWithVersion<TGeneratedTypes['collections'][T]>> => {\n    const { findVersionByID } = localOperations\n    return findVersionByID<T>(this, options)\n  }\n\n  /**\n   * @description Find versions with criteria\n   * @param options\n   * @returns versions satisfying query\n   */\n  findVersions = async <T extends keyof TGeneratedTypes['collections']>(\n    options: FindVersionsOptions<T>,\n  ): Promise<PaginatedDocs<TypeWithVersion<TGeneratedTypes['collections'][T]>>> => {\n    const { findVersions } = localOperations\n    return findVersions<T>(this, options)\n  }\n\n  forgotPassword = async <T extends keyof TGeneratedTypes['collections']>(\n    options: ForgotPasswordOptions<T>,\n  ): Promise<ForgotPasswordResult> => {\n    const { forgotPassword } = localOperations.auth\n    return forgotPassword<T>(this, options)\n  }\n\n  getAPIURL = (): string => `${this.config.serverURL}${this.config.routes.api}`\n\n  getAdminURL = (): string => `${this.config.serverURL}${this.config.routes.admin}`\n\n  globals: Globals\n\n  logger: pino.Logger\n\n  login = async <T extends keyof TGeneratedTypes['collections']>(\n    options: LoginOptions<T>,\n  ): Promise<LoginResult & { user: TGeneratedTypes['collections'][T] }> => {\n    const { login } = localOperations.auth\n    return login<T>(this, options)\n  }\n\n  /**\n   * @description Find document by ID\n   * @param options\n   * @returns document with specified ID\n   */\n\n  resetPassword = async <T extends keyof TGeneratedTypes['collections']>(\n    options: ResetPasswordOptions<T>,\n  ): Promise<ResetPasswordResult> => {\n    const { resetPassword } = localOperations.auth\n    return resetPassword<T>(this, options)\n  }\n\n  /**\n   * @description Restore global version by ID\n   * @param options\n   * @returns version with specified ID\n   */\n  restoreGlobalVersion = async <T extends keyof TGeneratedTypes['globals']>(\n    options: RestoreGlobalVersionOptions<T>,\n  ): Promise<TGeneratedTypes['globals'][T]> => {\n    const { restoreVersion } = localGlobalOperations\n    return restoreVersion<T>(this, options)\n  }\n\n  /**\n   * @description Restore version by ID\n   * @param options\n   * @returns version with specified ID\n   */\n  restoreVersion = async <T extends keyof TGeneratedTypes['collections']>(\n    options: RestoreVersionOptions<T>,\n  ): Promise<TGeneratedTypes['collections'][T]> => {\n    const { restoreVersion } = localOperations\n    return restoreVersion<T>(this, options)\n  }\n\n  schema: GraphQLSchema\n\n  secret: string\n\n  sendEmail: (message: SendMailOptions) => Promise<unknown>\n\n  types: {\n    arrayTypes: any\n    blockInputTypes: any\n    blockTypes: any\n    fallbackLocaleInputType?: any\n    groupTypes: any\n    localeInputType?: any\n    tabTypes: any\n  }\n\n  unlock = async <T extends keyof TGeneratedTypes['collections']>(\n    options: UnlockOptions<T>,\n  ): Promise<boolean> => {\n    const { unlock } = localOperations.auth\n    return unlock(this, options)\n  }\n\n  updateGlobal = async <T extends keyof TGeneratedTypes['globals']>(\n    options: UpdateGlobalOptions<T>,\n  ): Promise<TGeneratedTypes['globals'][T]> => {\n    const { update } = localGlobalOperations\n    return update<T>(this, options)\n  }\n\n  validationRules: (args: OperationArgs<any>) => ValidationRule[]\n\n  verifyEmail = async <T extends keyof TGeneratedTypes['collections']>(\n    options: VerifyEmailOptions<T>,\n  ): Promise<boolean> => {\n    const { verifyEmail } = localOperations.auth\n    return verifyEmail(this, options)\n  }\n\n  versions: {\n    [slug: string]: any // TODO: Type this\n  } = {}\n\n  delete<T extends keyof TGeneratedTypes['collections']>(\n    options: DeleteOptions<T>,\n  ): Promise<BulkOperationResult<T> | TGeneratedTypes['collections'][T]> {\n    const { deleteLocal } = localOperations\n    return deleteLocal<T>(this, options)\n  }\n\n  /**\n   * @description delete one or more documents\n   * @param options\n   * @returns Updated document(s)\n   */\n  delete<T extends keyof TGeneratedTypes['collections']>(\n    options: DeleteByIDOptions<T>,\n  ): Promise<TGeneratedTypes['collections'][T]>\n\n  delete<T extends keyof TGeneratedTypes['collections']>(\n    options: DeleteManyOptions<T>,\n  ): Promise<BulkOperationResult<T>>\n\n  /**\n   * @description Initializes Payload\n   * @param options\n   */\n  // @ts-expect-error // TODO: TypeScript hallucinating again. fix later\n  async init(options: InitOptions): Promise<Payload> {\n    this.logger = Logger('payload', options.loggerOptions, options.loggerDestination)\n\n    this.config = await options.config\n\n    if (!this.config.secret) {\n      throw new Error('Error: missing secret key. A secret key is needed to secure Payload.')\n    }\n\n    this.secret = crypto.createHash('sha256').update(this.config.secret).digest('hex').slice(0, 32)\n\n    this.globals = {\n      config: this.config.globals,\n    }\n    this.config.collections.forEach((collection) => {\n      this.collections[collection.slug] = {\n        config: collection,\n      }\n    })\n\n    this.db = this.config.db.init({ payload: this })\n    this.db.payload = this\n\n    if (this.db?.init) {\n      await this.db.init(this)\n    }\n\n    if (!options.disableDBConnect && this.db.connect) {\n      await this.db.connect(this)\n    }\n\n    this.logger.info('Starting Payload...')\n\n    // Configure email service\n    const emailOptions = options.email ? { ...options.email } : this.config.email\n    if (options.email && this.config.email) {\n      this.logger.warn(\n        'Email options provided in both init options and config. Using init options.',\n      )\n    }\n\n    this.emailOptions = emailOptions ?? emailDefaults\n    this.email = buildEmail(this.emailOptions, this.logger)\n    this.sendEmail = sendEmail.bind(this)\n\n    serverInitTelemetry(this)\n\n    // 1. loop over collections, if collection has auth strategy, initialize and push to array\n    let jwtStrategyEnabled = false\n    this.authStrategies = this.config.collections.reduce((authStrategies, collection) => {\n      if (collection?.auth) {\n        if (collection.auth.strategies.length > 0) {\n          authStrategies.push(...collection.auth.strategies)\n        }\n\n        // 2. if api key enabled, push api key strategy into the array\n        if (collection.auth?.useAPIKey) {\n          authStrategies.push({\n            name: `${collection.slug}-api-key`,\n            authenticate: APIKeyAuthentication(collection),\n          })\n        }\n\n        // 3. if localStrategy flag is true\n        if (!collection.auth.disableLocalStrategy && !jwtStrategyEnabled) {\n          jwtStrategyEnabled = true\n        }\n      }\n\n      return authStrategies\n    }, [] as AuthStrategy[])\n\n    // 4. if enabled, push jwt strategy into authStrategies last\n    if (jwtStrategyEnabled) {\n      this.authStrategies.push({\n        name: 'local-jwt',\n        authenticate: JWTAuthentication,\n      })\n    }\n\n    if (!options.disableOnInit) {\n      if (typeof options.onInit === 'function') await options.onInit(this)\n      if (typeof this.config.onInit === 'function') await this.config.onInit(this)\n    }\n\n    return this\n  }\n\n  update<T extends keyof TGeneratedTypes['collections']>(\n    options: UpdateManyOptions<T>,\n  ): Promise<BulkOperationResult<T>>\n\n  /**\n   * @description Update one or more documents\n   * @param options\n   * @returns Updated document(s)\n   */\n  update<T extends keyof TGeneratedTypes['collections']>(\n    options: UpdateByIDOptions<T>,\n  ): Promise<TGeneratedTypes['collections'][T]>\n\n  update<T extends keyof TGeneratedTypes['collections']>(\n    options: UpdateOptions<T>,\n  ): Promise<BulkOperationResult<T> | TGeneratedTypes['collections'][T]> {\n    const { update } = localOperations\n    return update<T>(this, options)\n  }\n}\n\nconst initialized = new BasePayload()\n\nexport default initialized\n\nlet cached = global._payload\n\nif (!cached) {\n  // eslint-disable-next-line no-multi-assign\n  cached = global._payload = { payload: null, promise: null }\n}\n\nexport const getPayload = async (options?: InitOptions): Promise<BasePayload<GeneratedTypes>> => {\n  if (cached.payload) {\n    return cached.payload\n  }\n\n  if (!cached.promise) {\n    cached.promise = new BasePayload<GeneratedTypes>().init(options)\n  }\n\n  try {\n    cached.payload = await cached.promise\n  } catch (e) {\n    cached.promise = null\n    throw e\n  }\n\n  return cached.payload\n}\n\ntype GeneratedTypes = {\n  collections: {\n    [slug: number | string | symbol]: TypeWithID & Record<string, unknown>\n  }\n  globals: {\n    [slug: number | string | symbol]: GlobalTypeWithID & Record<string, unknown>\n  }\n}\n\ntype Payload = BasePayload<GeneratedTypes>\n\ninterface RequestContext {\n  [key: string]: unknown\n}\n\n// type DatabaseAdapter = BaseDatabaseAdapter\n\nexport type { GeneratedTypes, Payload, RequestContext }\n"],"names":["BasePayload","getPayload","authStrategies","collections","config","create","options","localOperations","db","decrypt","email","emailOptions","encrypt","extensions","find","findByID","findGlobal","findOne","localGlobalOperations","findGlobalVersionByID","findVersionByID","findGlobalVersions","findVersions","forgotPassword","auth","getAPIURL","serverURL","routes","api","getAdminURL","admin","globals","logger","login","resetPassword","restoreGlobalVersion","restoreVersion","schema","secret","sendEmail","types","unlock","updateGlobal","update","validationRules","verifyEmail","versions","delete","deleteLocal","init","Logger","loggerOptions","loggerDestination","Error","crypto","createHash","digest","slice","forEach","collection","slug","payload","disableDBConnect","connect","info","warn","emailDefaults","buildEmail","bind","serverInitTelemetry","jwtStrategyEnabled","reduce","strategies","length","push","useAPIKey","name","authenticate","APIKeyAuthentication","disableLocalStrategy","JWTAuthentication","disableOnInit","onInit","initialized","cached","global","_payload","promise","e"],"mappings":"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"}

package/dist/preferences/deleteUserPreferences.d.ts

@@ -1,6 +1,6 @@
+import type { Payload } from '..';
 import type { SanitizedCollectionConfig } from '../collections/config/types';
-import type { PayloadRequest } from '../express/types';
-import type { Payload } from '../index';
+import type { PayloadRequest } from '../types';
 type Args = {
     collectionConfig: SanitizedCollectionConfig;
     /**

package/dist/preferences/deleteUserPreferences.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deleteUserPreferences.d.ts","sourceRoot":"","sources":["../../src/preferences/deleteUserPreferences.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAA;AAC5E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AACtD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAEvC,KAAK,IAAI,GAAG;IACV,gBAAgB,EAAE,yBAAyB,CAAA;IAC3C;;OAEG;IACH,GAAG,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAA;IACxB,OAAO,EAAE,OAAO,CAAA;IAChB,GAAG,EAAE,cAAc,CAAA;CACpB,CAAA;AACD,eAAO,MAAM,qBAAqB,4CAAmD,IAAI,kBAwBxF,CAAA"}
+{"version":3,"file":"deleteUserPreferences.d.ts","sourceRoot":"","sources":["../../src/preferences/deleteUserPreferences.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,IAAI,CAAA;AACjC,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAA;AAC5E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAE9C,KAAK,IAAI,GAAG;IACV,gBAAgB,EAAE,yBAAyB,CAAA;IAC3C;;OAEG;IACH,GAAG,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAA;IACxB,OAAO,EAAE,OAAO,CAAA;IAChB,GAAG,EAAE,cAAc,CAAA;CACpB,CAAA;AACD,eAAO,MAAM,qBAAqB,4CAAmD,IAAI,kBAwBxF,CAAA"}

package/dist/preferences/deleteUserPreferences.js

@@ -40,4 +40,4 @@ const deleteUserPreferences = async ({ collectionConfig, ids, payload, req })=>{
     });
 };
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/preferences/operations/delete.js

@@ -56,8 +56,8 @@ async function deleteOperation(args) {
     if (result.docs.length === 1) {
         return result.docs[0];
     }
-    throw new _NotFound.default();
+    throw new _NotFound.default(req.t);
 }
 const _default = deleteOperation;
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/preferences/operations/update.d.ts

@@ -5,7 +5,7 @@ declare function update(args: PreferenceUpdateRequest): Promise<{
         relationTo: string;
         value: string;
     };
-    value: undefined;
+    value: unknown;
 }>;
 export default update;
 //# sourceMappingURL=update.d.ts.map

package/dist/preferences/preferencesCollection.js

@@ -8,14 +8,9 @@ Object.defineProperty(exports, "default", {
         return _default;
     }
 });
-const _delete = /*#__PURE__*/ _interop_require_default(require("./requestHandlers/delete"));
-const _findOne = /*#__PURE__*/ _interop_require_default(require("./requestHandlers/findOne"));
-const _update = /*#__PURE__*/ _interop_require_default(require("./requestHandlers/update"));
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
+const _delete = require("./requestHandlers/delete");
+const _findOne = require("./requestHandlers/findOne");
+const _update = require("./requestHandlers/update");
 const preferenceAccess = ({ req })=>({
         'user.value': {
             equals: req?.user?.id
@@ -32,17 +27,17 @@ const getPreferencesCollection = (config)=>({
         },
         endpoints: [
             {
-                handler: _findOne.default,
+                handler: _findOne.findByIDHandler,
                 method: 'get',
                 path: '/:key'
             },
             {
-                handler: _delete.default,
+                handler: _delete.deleteHandler,
                 method: 'delete',
                 path: '/:key'
             },
             {
-                handler: _update.default,
+                handler: _update.updateHandler,
                 method: 'post',
                 path: '/:key'
             }
@@ -81,4 +76,4 @@ const getPreferencesCollection = (config)=>({
     });
 const _default = getPreferencesCollection;
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/preferences/requestHandlers/delete.d.ts

@@ -1,6 +1,3 @@
-import type { NextFunction, Response } from 'express';
-import type { PayloadRequest } from '../../express/types';
-export default function deleteHandler(req: PayloadRequest, res: Response, next: NextFunction): Promise<Response<{
-    message: string;
-}> | void>;
+import type { PayloadHandler } from '../../exports/config';
+export declare const deleteHandler: PayloadHandler;
 //# sourceMappingURL=delete.d.ts.map

package/dist/preferences/requestHandlers/delete.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["../../../src/preferences/requestHandlers/delete.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAIrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAKzD,wBAA8B,aAAa,CACzC,GAAG,EAAE,cAAc,EACnB,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,QAAQ,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,IAAI,CAAC,CAc/C"}
+{"version":3,"file":"delete.d.ts","sourceRoot":"","sources":["../../../src/preferences/requestHandlers/delete.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAI1D,eAAO,MAAM,aAAa,EAAE,cAgB3B,CAAA"}

package/dist/preferences/requestHandlers/delete.js

@@ -2,33 +2,31 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "default", {
+Object.defineProperty(exports, "deleteHandler", {
     enumerable: true,
     get: function() {
         return deleteHandler;
     }
 });
 const _httpstatus = /*#__PURE__*/ _interop_require_default(require("http-status"));
-const _formatSuccess = /*#__PURE__*/ _interop_require_default(require("../../express/responses/formatSuccess"));
 const _delete = /*#__PURE__*/ _interop_require_default(require("../operations/delete"));
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-async function deleteHandler(req, res, next) {
-    try {
-        await (0, _delete.default)({
-            key: req.params.key,
-            req,
-            user: req.user
-        });
-        return res.status(_httpstatus.default.OK).json({
-            ...(0, _formatSuccess.default)(req.t('deletedSuccessfully'), 'message')
-        });
-    } catch (error) {
-        return next(error);
-    }
-}
+const deleteHandler = async (req)=>{
+    const result = await (0, _delete.default)({
+        key: req.routeParams?.key,
+        req,
+        user: req.user
+    });
+    return Response.json({
+        ...result,
+        message: req.t('general:deletedSuccessfully')
+    }, {
+        status: _httpstatus.default.OK
+    });
+};
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wcmVmZXJlbmNlcy9yZXF1ZXN0SGFuZGxlcnMvZGVsZXRlLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgTmV4dEZ1bmN0aW9uLCBSZXNwb25zZSB9IGZyb20gJ2V4cHJlc3MnXG5cbmltcG9ydCBodHRwU3RhdHVzIGZyb20gJ2h0dHAtc3RhdHVzJ1xuXG5pbXBvcnQgdHlwZSB7IFBheWxvYWRSZXF1ZXN0IH0gZnJvbSAnLi4vLi4vZXhwcmVzcy90eXBlcydcblxuaW1wb3J0IGZvcm1hdFN1Y2Nlc3NSZXNwb25zZSBmcm9tICcuLi8uLi9leHByZXNzL3Jlc3BvbnNlcy9mb3JtYXRTdWNjZXNzJ1xuaW1wb3J0IGRlbGV0ZU9wZXJhdGlvbiBmcm9tICcuLi9vcGVyYXRpb25zL2RlbGV0ZSdcblxuZXhwb3J0IGRlZmF1bHQgYXN5bmMgZnVuY3Rpb24gZGVsZXRlSGFuZGxlcihcbiAgcmVxOiBQYXlsb2FkUmVxdWVzdCxcbiAgcmVzOiBSZXNwb25zZSxcbiAgbmV4dDogTmV4dEZ1bmN0aW9uLFxuKTogUHJvbWlzZTxSZXNwb25zZTx7IG1lc3NhZ2U6IHN0cmluZyB9PiB8IHZvaWQ+IHtcbiAgdHJ5IHtcbiAgICBhd2FpdCBkZWxldGVPcGVyYXRpb24oe1xuICAgICAga2V5OiByZXEucGFyYW1zLmtleSxcbiAgICAgIHJlcSxcbiAgICAgIHVzZXI6IHJlcS51c2VyLFxuICAgIH0pXG5cbiAgICByZXR1cm4gcmVzLnN0YXR1cyhodHRwU3RhdHVzLk9LKS5qc29uKHtcbiAgICAgIC4uLmZvcm1hdFN1Y2Nlc3NSZXNwb25zZShyZXEudCgnZGVsZXRlZFN1Y2Nlc3NmdWxseScpLCAnbWVzc2FnZScpLFxuICAgIH0pXG4gIH0gY2F0Y2ggKGVycm9yKSB7XG4gICAgcmV0dXJuIG5leHQoZXJyb3IpXG4gIH1cbn1cbiJdLCJuYW1lcyI6WyJkZWxldGVIYW5kbGVyIiwicmVxIiwicmVzIiwibmV4dCIsImRlbGV0ZU9wZXJhdGlvbiIsImtleSIsInBhcmFtcyIsInVzZXIiLCJzdGF0dXMiLCJodHRwU3RhdHVzIiwiT0siLCJqc29uIiwiZm9ybWF0U3VjY2Vzc1Jlc3BvbnNlIiwidCIsImVycm9yIl0sIm1hcHBpbmdzIjoiOzs7OytCQVNBOzs7ZUFBOEJBOzs7bUVBUFA7c0VBSVc7K0RBQ047Ozs7OztBQUViLGVBQWVBLGNBQzVCQyxHQUFtQixFQUNuQkMsR0FBYSxFQUNiQyxJQUFrQjtJQUVsQixJQUFJO1FBQ0YsTUFBTUMsSUFBQUEsZUFBZSxFQUFDO1lBQ3BCQyxLQUFLSixJQUFJSyxNQUFNLENBQUNELEdBQUc7WUFDbkJKO1lBQ0FNLE1BQU1OLElBQUlNLElBQUk7UUFDaEI7UUFFQSxPQUFPTCxJQUFJTSxNQUFNLENBQUNDLG1CQUFVLENBQUNDLEVBQUUsRUFBRUMsSUFBSSxDQUFDO1lBQ3BDLEdBQUdDLElBQUFBLHNCQUFxQixFQUFDWCxJQUFJWSxDQUFDLENBQUMsd0JBQXdCLFVBQVU7UUFDbkU7SUFDRixFQUFFLE9BQU9DLE9BQU87UUFDZCxPQUFPWCxLQUFLVztJQUNkO0FBQ0YifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wcmVmZXJlbmNlcy9yZXF1ZXN0SGFuZGxlcnMvZGVsZXRlLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBodHRwU3RhdHVzIGZyb20gJ2h0dHAtc3RhdHVzJ1xuXG5pbXBvcnQgdHlwZSB7IFBheWxvYWRIYW5kbGVyIH0gZnJvbSAnLi4vLi4vZXhwb3J0cy9jb25maWcnXG5cbmltcG9ydCBkZWxldGVPcGVyYXRpb24gZnJvbSAnLi4vb3BlcmF0aW9ucy9kZWxldGUnXG5cbmV4cG9ydCBjb25zdCBkZWxldGVIYW5kbGVyOiBQYXlsb2FkSGFuZGxlciA9IGFzeW5jIChyZXEpOiBQcm9taXNlPFJlc3BvbnNlPiA9PiB7XG4gIGNvbnN0IHJlc3VsdCA9IGF3YWl0IGRlbGV0ZU9wZXJhdGlvbih7XG4gICAga2V5OiByZXEucm91dGVQYXJhbXM/LmtleSBhcyBzdHJpbmcsXG4gICAgcmVxLFxuICAgIHVzZXI6IHJlcS51c2VyLFxuICB9KVxuXG4gIHJldHVybiBSZXNwb25zZS5qc29uKFxuICAgIHtcbiAgICAgIC4uLnJlc3VsdCxcbiAgICAgIG1lc3NhZ2U6IHJlcS50KCdnZW5lcmFsOmRlbGV0ZWRTdWNjZXNzZnVsbHknKSxcbiAgICB9LFxuICAgIHtcbiAgICAgIHN0YXR1czogaHR0cFN0YXR1cy5PSyxcbiAgICB9LFxuICApXG59XG4iXSwibmFtZXMiOlsiZGVsZXRlSGFuZGxlciIsInJlcSIsInJlc3VsdCIsImRlbGV0ZU9wZXJhdGlvbiIsImtleSIsInJvdXRlUGFyYW1zIiwidXNlciIsIlJlc3BvbnNlIiwianNvbiIsIm1lc3NhZ2UiLCJ0Iiwic3RhdHVzIiwiaHR0cFN0YXR1cyIsIk9LIl0sIm1hcHBpbmdzIjoiOzs7OytCQU1hQTs7O2VBQUFBOzs7bUVBTlU7K0RBSUs7Ozs7OztBQUVyQixNQUFNQSxnQkFBZ0MsT0FBT0M7SUFDbEQsTUFBTUMsU0FBUyxNQUFNQyxJQUFBQSxlQUFlLEVBQUM7UUFDbkNDLEtBQUtILElBQUlJLFdBQVcsRUFBRUQ7UUFDdEJIO1FBQ0FLLE1BQU1MLElBQUlLLElBQUk7SUFDaEI7SUFFQSxPQUFPQyxTQUFTQyxJQUFJLENBQ2xCO1FBQ0UsR0FBR04sTUFBTTtRQUNUTyxTQUFTUixJQUFJUyxDQUFDLENBQUM7SUFDakIsR0FDQTtRQUNFQyxRQUFRQyxtQkFBVSxDQUFDQyxFQUFFO0lBQ3ZCO0FBRUoifQ==

package/dist/preferences/requestHandlers/findOne.d.ts

@@ -1,5 +1,3 @@
-import type { NextFunction, Response } from 'express';
-import type { GeneratedTypes } from '../../';
-import type { PayloadRequest } from '../../express/types';
-export default function findOneHandler(req: PayloadRequest, res: Response, next: NextFunction): Promise<Response<GeneratedTypes['collections']['_preference']> | void>;
+import type { PayloadHandler } from '../../exports/config';
+export declare const findByIDHandler: PayloadHandler;
 //# sourceMappingURL=findOne.d.ts.map

package/dist/preferences/requestHandlers/findOne.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findOne.d.ts","sourceRoot":"","sources":["../../../src/preferences/requestHandlers/findOne.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAIrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AAC5C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAIzD,wBAA8B,cAAc,CAC1C,GAAG,EAAE,cAAc,EACnB,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC,aAAa,CAAC,CAAC,aAAa,CAAC,CAAC,GAAG,IAAI,CAAC,CAcxE"}
+{"version":3,"file":"findOne.d.ts","sourceRoot":"","sources":["../../../src/preferences/requestHandlers/findOne.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAI1D,eAAO,MAAM,eAAe,EAAE,cAoB7B,CAAA"}

package/dist/preferences/requestHandlers/findOne.js

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "default", {
+Object.defineProperty(exports, "findByIDHandler", {
     enumerable: true,
     get: function() {
-        return findOneHandler;
+        return findByIDHandler;
     }
 });
 const _httpstatus = /*#__PURE__*/ _interop_require_default(require("http-status"));
@@ -15,20 +15,20 @@ function _interop_require_default(obj) {
         default: obj
     };
 }
-async function findOneHandler(req, res, next) {
-    try {
-        const result = await (0, _findOne.default)({
-            key: req.params.key,
-            req,
-            user: req.user
-        });
-        return res.status(_httpstatus.default.OK).json(result || {
+const findByIDHandler = async (req)=>{
+    const result = await (0, _findOne.default)({
+        key: req.routeParams?.key,
+        req,
+        user: req.user
+    });
+    return Response.json({
+        ...result ? result : {
             message: req.t('general:notFound'),
             value: null
-        });
-    } catch (error) {
-        return next(error);
-    }
-}
+        }
+    }, {
+        status: _httpstatus.default.OK
+    });
+};
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wcmVmZXJlbmNlcy9yZXF1ZXN0SGFuZGxlcnMvZmluZE9uZS50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IE5leHRGdW5jdGlvbiwgUmVzcG9uc2UgfSBmcm9tICdleHByZXNzJ1xuXG5pbXBvcnQgaHR0cFN0YXR1cyBmcm9tICdodHRwLXN0YXR1cydcblxuaW1wb3J0IHR5cGUgeyBHZW5lcmF0ZWRUeXBlcyB9IGZyb20gJy4uLy4uLydcbmltcG9ydCB0eXBlIHsgUGF5bG9hZFJlcXVlc3QgfSBmcm9tICcuLi8uLi9leHByZXNzL3R5cGVzJ1xuXG5pbXBvcnQgZmluZE9uZSBmcm9tICcuLi9vcGVyYXRpb25zL2ZpbmRPbmUnXG5cbmV4cG9ydCBkZWZhdWx0IGFzeW5jIGZ1bmN0aW9uIGZpbmRPbmVIYW5kbGVyKFxuICByZXE6IFBheWxvYWRSZXF1ZXN0LFxuICByZXM6IFJlc3BvbnNlLFxuICBuZXh0OiBOZXh0RnVuY3Rpb24sXG4pOiBQcm9taXNlPFJlc3BvbnNlPEdlbmVyYXRlZFR5cGVzWydjb2xsZWN0aW9ucyddWydfcHJlZmVyZW5jZSddPiB8IHZvaWQ+IHtcbiAgdHJ5IHtcbiAgICBjb25zdCByZXN1bHQgPSBhd2FpdCBmaW5kT25lKHtcbiAgICAgIGtleTogcmVxLnBhcmFtcy5rZXksXG4gICAgICByZXEsXG4gICAgICB1c2VyOiByZXEudXNlcixcbiAgICB9KVxuXG4gICAgcmV0dXJuIHJlc1xuICAgICAgLnN0YXR1cyhodHRwU3RhdHVzLk9LKVxuICAgICAgLmpzb24ocmVzdWx0IHx8IHsgbWVzc2FnZTogcmVxLnQoJ2dlbmVyYWw6bm90Rm91bmQnKSwgdmFsdWU6IG51bGwgfSlcbiAgfSBjYXRjaCAoZXJyb3IpIHtcbiAgICByZXR1cm4gbmV4dChlcnJvcilcbiAgfVxufVxuIl0sIm5hbWVzIjpbImZpbmRPbmVIYW5kbGVyIiwicmVxIiwicmVzIiwibmV4dCIsInJlc3VsdCIsImZpbmRPbmUiLCJrZXkiLCJwYXJhbXMiLCJ1c2VyIiwic3RhdHVzIiwiaHR0cFN0YXR1cyIsIk9LIiwianNvbiIsIm1lc3NhZ2UiLCJ0IiwidmFsdWUiLCJlcnJvciJdLCJtYXBwaW5ncyI6Ijs7OzsrQkFTQTs7O2VBQThCQTs7O21FQVBQO2dFQUtIOzs7Ozs7QUFFTCxlQUFlQSxlQUM1QkMsR0FBbUIsRUFDbkJDLEdBQWEsRUFDYkMsSUFBa0I7SUFFbEIsSUFBSTtRQUNGLE1BQU1DLFNBQVMsTUFBTUMsSUFBQUEsZ0JBQU8sRUFBQztZQUMzQkMsS0FBS0wsSUFBSU0sTUFBTSxDQUFDRCxHQUFHO1lBQ25CTDtZQUNBTyxNQUFNUCxJQUFJTyxJQUFJO1FBQ2hCO1FBRUEsT0FBT04sSUFDSk8sTUFBTSxDQUFDQyxtQkFBVSxDQUFDQyxFQUFFLEVBQ3BCQyxJQUFJLENBQUNSLFVBQVU7WUFBRVMsU0FBU1osSUFBSWEsQ0FBQyxDQUFDO1lBQXFCQyxPQUFPO1FBQUs7SUFDdEUsRUFBRSxPQUFPQyxPQUFPO1FBQ2QsT0FBT2IsS0FBS2E7SUFDZDtBQUNGIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9wcmVmZXJlbmNlcy9yZXF1ZXN0SGFuZGxlcnMvZmluZE9uZS50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgaHR0cFN0YXR1cyBmcm9tICdodHRwLXN0YXR1cydcblxuaW1wb3J0IHR5cGUgeyBQYXlsb2FkSGFuZGxlciB9IGZyb20gJy4uLy4uL2V4cG9ydHMvY29uZmlnJ1xuXG5pbXBvcnQgZmluZE9uZSBmcm9tICcuLi9vcGVyYXRpb25zL2ZpbmRPbmUnXG5cbmV4cG9ydCBjb25zdCBmaW5kQnlJREhhbmRsZXI6IFBheWxvYWRIYW5kbGVyID0gYXN5bmMgKHJlcSk6IFByb21pc2U8UmVzcG9uc2U+ID0+IHtcbiAgY29uc3QgcmVzdWx0ID0gYXdhaXQgZmluZE9uZSh7XG4gICAga2V5OiByZXEucm91dGVQYXJhbXM/LmtleSBhcyBzdHJpbmcsXG4gICAgcmVxLFxuICAgIHVzZXI6IHJlcS51c2VyLFxuICB9KVxuXG4gIHJldHVybiBSZXNwb25zZS5qc29uKFxuICAgIHtcbiAgICAgIC4uLihyZXN1bHRcbiAgICAgICAgPyByZXN1bHRcbiAgICAgICAgOiB7XG4gICAgICAgICAgICBtZXNzYWdlOiByZXEudCgnZ2VuZXJhbDpub3RGb3VuZCcpLFxuICAgICAgICAgICAgdmFsdWU6IG51bGwsXG4gICAgICAgICAgfSksXG4gICAgfSxcbiAgICB7XG4gICAgICBzdGF0dXM6IGh0dHBTdGF0dXMuT0ssXG4gICAgfSxcbiAgKVxufVxuIl0sIm5hbWVzIjpbImZpbmRCeUlESGFuZGxlciIsInJlcSIsInJlc3VsdCIsImZpbmRPbmUiLCJrZXkiLCJyb3V0ZVBhcmFtcyIsInVzZXIiLCJSZXNwb25zZSIsImpzb24iLCJtZXNzYWdlIiwidCIsInZhbHVlIiwic3RhdHVzIiwiaHR0cFN0YXR1cyIsIk9LIl0sIm1hcHBpbmdzIjoiOzs7OytCQU1hQTs7O2VBQUFBOzs7bUVBTlU7Z0VBSUg7Ozs7OztBQUViLE1BQU1BLGtCQUFrQyxPQUFPQztJQUNwRCxNQUFNQyxTQUFTLE1BQU1DLElBQUFBLGdCQUFPLEVBQUM7UUFDM0JDLEtBQUtILElBQUlJLFdBQVcsRUFBRUQ7UUFDdEJIO1FBQ0FLLE1BQU1MLElBQUlLLElBQUk7SUFDaEI7SUFFQSxPQUFPQyxTQUFTQyxJQUFJLENBQ2xCO1FBQ0UsR0FBSU4sU0FDQUEsU0FDQTtZQUNFTyxTQUFTUixJQUFJUyxDQUFDLENBQUM7WUFDZkMsT0FBTztRQUNULENBQUM7SUFDUCxHQUNBO1FBQ0VDLFFBQVFDLG1CQUFVLENBQUNDLEVBQUU7SUFDdkI7QUFFSiJ9

package/dist/preferences/requestHandlers/update.d.ts

@@ -1,5 +1,3 @@
-import type { NextFunction, Response } from 'express';
-import type { GeneratedTypes } from '../../';
-import type { PayloadRequest } from '../../express/types';
-export default function updateHandler(req: PayloadRequest, res: Response, next: NextFunction): Promise<Response<GeneratedTypes['collections']['_preference']> | void>;
+import type { PayloadHandler } from '../../exports/config';
+export declare const updateHandler: PayloadHandler;
 //# sourceMappingURL=update.d.ts.map

package/dist/preferences/requestHandlers/update.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["../../../src/preferences/requestHandlers/update.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAIrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AAC5C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAKzD,wBAA8B,aAAa,CACzC,GAAG,EAAE,cAAc,EACnB,GAAG,EAAE,QAAQ,EACb,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC,aAAa,CAAC,CAAC,aAAa,CAAC,CAAC,GAAG,IAAI,CAAC,CAgBxE"}
+{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["../../../src/preferences/requestHandlers/update.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAI1D,eAAO,MAAM,aAAa,EAAE,cAmB3B,CAAA"}