payload 1.9.2 → 1.9.4

package/dist/auth/strategies/local/incrementLoginAttempts.js

@@ -1,36 +1,36 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.incrementLoginAttempts = void 0;
-const incrementLoginAttempts = async ({ payload, doc, collection, }) => {
-    const { auth: { maxLoginAttempts, lockTime, } } = collection;
-    if ('lockUntil' in doc && typeof doc.lockUntil === 'string') {
-        const lockUntil = Math.floor(new Date(doc.lockUntil).getTime() / 1000);
-        // Expired lock, restart count at 1
-        if (lockUntil < Date.now()) {
-            await payload.update({
-                collection: collection.slug,
-                id: doc.id,
-                data: {
-                    loginAttempts: 1,
-                    lockUntil: null,
-                }
-            });
-        }
-        return;
-    }
-    const data = {
-        loginAttempts: Number(doc.loginAttempts) + 1,
-    };
-    // Lock the account if at max attempts and not already locked
-    if (typeof doc.loginAttempts === 'number' && doc.loginAttempts + 1 >= maxLoginAttempts) {
-        const lockUntil = new Date((Date.now() + lockTime));
-        data.lockUntil = lockUntil;
-    }
-    await payload.update({
-        collection: collection.slug,
-        id: doc.id,
-        data,
-    });
-};
-exports.incrementLoginAttempts = incrementLoginAttempts;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.incrementLoginAttempts = void 0;
+const incrementLoginAttempts = async ({ payload, doc, collection, }) => {
+    const { auth: { maxLoginAttempts, lockTime, } } = collection;
+    if ('lockUntil' in doc && typeof doc.lockUntil === 'string') {
+        const lockUntil = Math.floor(new Date(doc.lockUntil).getTime() / 1000);
+        // Expired lock, restart count at 1
+        if (lockUntil < Date.now()) {
+            await payload.update({
+                collection: collection.slug,
+                id: doc.id,
+                data: {
+                    loginAttempts: 1,
+                    lockUntil: null,
+                }
+            });
+        }
+        return;
+    }
+    const data = {
+        loginAttempts: Number(doc.loginAttempts) + 1,
+    };
+    // Lock the account if at max attempts and not already locked
+    if (typeof doc.loginAttempts === 'number' && doc.loginAttempts + 1 >= maxLoginAttempts) {
+        const lockUntil = new Date((Date.now() + lockTime));
+        data.lockUntil = lockUntil;
+    }
+    await payload.update({
+        collection: collection.slug,
+        id: doc.id,
+        data,
+    });
+};
+exports.incrementLoginAttempts = incrementLoginAttempts;
 //# sourceMappingURL=incrementLoginAttempts.js.map

package/dist/auth/strategies/local/register.d.ts

@@ -1,10 +1,10 @@
-import { Payload } from '../../..';
-import { SanitizedCollectionConfig } from '../../../collections/config/types';
-type Args = {
-    collection: SanitizedCollectionConfig;
-    doc: Record<string, unknown>;
-    password: string;
-    payload: Payload;
-};
-export declare const registerLocalStrategy: ({ collection, doc, password, payload, }: Args) => Promise<Record<string, unknown>>;
-export {};
+import { Payload } from '../../..';
+import { SanitizedCollectionConfig } from '../../../collections/config/types';
+type Args = {
+    collection: SanitizedCollectionConfig;
+    doc: Record<string, unknown>;
+    password: string;
+    payload: Payload;
+};
+export declare const registerLocalStrategy: ({ collection, doc, password, payload, }: Args) => Promise<Record<string, unknown>>;
+export {};

package/dist/auth/strategies/local/register.js

@@ -1,28 +1,28 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerLocalStrategy = void 0;
-const errors_1 = require("../../../errors");
-const generatePasswordSaltHash_1 = require("./generatePasswordSaltHash");
-const registerLocalStrategy = async ({ collection, doc, password, payload, }) => {
-    const existingUser = await payload.find({
-        collection: collection.slug,
-        depth: 0,
-        where: {
-            email: {
-                equals: doc.email,
-            }
-        }
-    });
-    if (existingUser.docs.length > 0) {
-        throw new errors_1.ValidationError([{ message: 'A user with the given email is already registered', field: 'email' }]);
-    }
-    const { salt, hash } = await (0, generatePasswordSaltHash_1.generatePasswordSaltHash)({ password });
-    const result = await payload.collections[collection.slug].Model.create({
-        ...doc,
-        salt,
-        hash
-    });
-    return result;
-};
-exports.registerLocalStrategy = registerLocalStrategy;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerLocalStrategy = void 0;
+const errors_1 = require("../../../errors");
+const generatePasswordSaltHash_1 = require("./generatePasswordSaltHash");
+const registerLocalStrategy = async ({ collection, doc, password, payload, }) => {
+    const existingUser = await payload.find({
+        collection: collection.slug,
+        depth: 0,
+        where: {
+            email: {
+                equals: doc.email,
+            }
+        }
+    });
+    if (existingUser.docs.length > 0) {
+        throw new errors_1.ValidationError([{ message: 'A user with the given email is already registered', field: 'email' }]);
+    }
+    const { salt, hash } = await (0, generatePasswordSaltHash_1.generatePasswordSaltHash)({ password });
+    const result = await payload.collections[collection.slug].Model.create({
+        ...doc,
+        salt,
+        hash
+    });
+    return result;
+};
+exports.registerLocalStrategy = registerLocalStrategy;
 //# sourceMappingURL=register.js.map

package/dist/auth/strategies/local/resetLoginAttempts.d.ts

@@ -1,9 +1,9 @@
-import { Payload } from "../../..";
-import { SanitizedCollectionConfig, TypeWithID } from "../../../collections/config/types";
-type Args = {
-    payload: Payload;
-    doc: TypeWithID & Record<string, unknown>;
-    collection: SanitizedCollectionConfig;
-};
-export declare const resetLoginAttempts: ({ payload, doc, collection, }: Args) => Promise<void>;
-export {};
+import { Payload } from "../../..";
+import { SanitizedCollectionConfig, TypeWithID } from "../../../collections/config/types";
+type Args = {
+    payload: Payload;
+    doc: TypeWithID & Record<string, unknown>;
+    collection: SanitizedCollectionConfig;
+};
+export declare const resetLoginAttempts: ({ payload, doc, collection, }: Args) => Promise<void>;
+export {};

package/dist/auth/strategies/local/resetLoginAttempts.js

@@ -1,15 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resetLoginAttempts = void 0;
-const resetLoginAttempts = async ({ payload, doc, collection, }) => {
-    await payload.update({
-        collection: collection.slug,
-        id: doc.id,
-        data: {
-            loginAttempts: 0,
-            lockUntil: null,
-        },
-    });
-};
-exports.resetLoginAttempts = resetLoginAttempts;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetLoginAttempts = void 0;
+const resetLoginAttempts = async ({ payload, doc, collection, }) => {
+    await payload.update({
+        collection: collection.slug,
+        id: doc.id,
+        data: {
+            loginAttempts: 0,
+            lockUntil: null,
+        },
+    });
+};
+exports.resetLoginAttempts = resetLoginAttempts;
 //# sourceMappingURL=resetLoginAttempts.js.map

package/dist/auth/types.d.ts

@@ -1,122 +1,122 @@
-import { Strategy } from 'passport';
-import { DeepRequired } from 'ts-essentials';
-import { PayloadRequest } from '../express/types';
-import { Where, PayloadMongooseDocument } from '../types';
-import { Payload } from '../payload';
-export type Permission = {
-    permission: boolean;
-    where?: Record<string, unknown>;
-};
-export type FieldPermissions = {
-    create: {
-        permission: boolean;
-    };
-    read: {
-        permission: boolean;
-    };
-    update: {
-        permission: boolean;
-    };
-    fields?: {
-        [field: string]: FieldPermissions;
-    };
-};
-export type CollectionPermission = {
-    create: Permission;
-    read: Permission;
-    update: Permission;
-    delete: Permission;
-    readVersions?: Permission;
-    fields: {
-        [field: string]: FieldPermissions;
-    };
-};
-export type GlobalPermission = {
-    read: Permission;
-    update: Permission;
-    readVersions?: Permission;
-    fields: {
-        [field: string]: FieldPermissions;
-    };
-};
-export type Permissions = {
-    canAccessAdmin: boolean;
-    collections: {
-        [collectionSlug: string]: CollectionPermission;
-    };
-    globals?: {
-        [globalSlug: string]: GlobalPermission;
-    };
-};
-export type User = {
-    id: string;
-    email: string;
-    collection: string;
-    [key: string]: unknown;
-};
-export interface UserDocument extends PayloadMongooseDocument {
-    setPassword: (pass: string) => Promise<void>;
-    authenticate: (pass: string) => Promise<void>;
-    resetPasswordExpiration: number;
-    email: string;
-    _verified?: boolean;
-}
-type GenerateVerifyEmailHTML = (args: {
-    req: PayloadRequest;
-    token: string;
-    user: any;
-}) => Promise<string> | string;
-type GenerateVerifyEmailSubject = (args: {
-    req: PayloadRequest;
-    token: string;
-    user: any;
-}) => Promise<string> | string;
-type GenerateForgotPasswordEmailHTML = (args?: {
-    req?: PayloadRequest;
-    token?: string;
-    user?: unknown;
-}) => Promise<string> | string;
-type GenerateForgotPasswordEmailSubject = (args?: {
-    req?: PayloadRequest;
-    token?: string;
-    user?: any;
-}) => Promise<string> | string;
-type AuthStrategy = ((ctx: Payload) => Strategy) | Strategy;
-export interface IncomingAuthType {
-    tokenExpiration?: number;
-    verify?: boolean | {
-        generateEmailHTML?: GenerateVerifyEmailHTML;
-        generateEmailSubject?: GenerateVerifyEmailSubject;
-    };
-    maxLoginAttempts?: number;
-    lockTime?: number;
-    useAPIKey?: boolean;
-    depth?: number;
-    cookies?: {
-        secure?: boolean;
-        sameSite?: boolean | 'none' | 'strict' | 'lax';
-        domain?: string;
-    };
-    forgotPassword?: {
-        generateEmailHTML?: GenerateForgotPasswordEmailHTML;
-        generateEmailSubject?: GenerateForgotPasswordEmailSubject;
-    };
-    disableLocalStrategy?: true;
-    strategies?: {
-        name?: string;
-        strategy: AuthStrategy;
-    }[];
-}
-export type VerifyConfig = {
-    generateEmailHTML?: GenerateVerifyEmailHTML;
-    generateEmailSubject?: GenerateVerifyEmailSubject;
-};
-export interface Auth extends Omit<DeepRequired<IncomingAuthType>, 'verify' | 'forgotPassword'> {
-    verify?: VerifyConfig | boolean;
-    forgotPassword?: {
-        generateEmailHTML?: GenerateForgotPasswordEmailHTML;
-        generateEmailSubject?: GenerateForgotPasswordEmailSubject;
-    };
-}
-export declare function hasWhereAccessResult(result: boolean | Where): result is Where;
-export {};
+import { Strategy } from 'passport';
+import { DeepRequired } from 'ts-essentials';
+import { PayloadRequest } from '../express/types';
+import { Where, PayloadMongooseDocument } from '../types';
+import { Payload } from '../payload';
+export type Permission = {
+    permission: boolean;
+    where?: Record<string, unknown>;
+};
+export type FieldPermissions = {
+    create: {
+        permission: boolean;
+    };
+    read: {
+        permission: boolean;
+    };
+    update: {
+        permission: boolean;
+    };
+    fields?: {
+        [field: string]: FieldPermissions;
+    };
+};
+export type CollectionPermission = {
+    create: Permission;
+    read: Permission;
+    update: Permission;
+    delete: Permission;
+    readVersions?: Permission;
+    fields: {
+        [field: string]: FieldPermissions;
+    };
+};
+export type GlobalPermission = {
+    read: Permission;
+    update: Permission;
+    readVersions?: Permission;
+    fields: {
+        [field: string]: FieldPermissions;
+    };
+};
+export type Permissions = {
+    canAccessAdmin: boolean;
+    collections: {
+        [collectionSlug: string]: CollectionPermission;
+    };
+    globals?: {
+        [globalSlug: string]: GlobalPermission;
+    };
+};
+export type User = {
+    id: string;
+    email: string;
+    collection: string;
+    [key: string]: unknown;
+};
+export interface UserDocument extends PayloadMongooseDocument {
+    setPassword: (pass: string) => Promise<void>;
+    authenticate: (pass: string) => Promise<void>;
+    resetPasswordExpiration: number;
+    email: string;
+    _verified?: boolean;
+}
+type GenerateVerifyEmailHTML = (args: {
+    req: PayloadRequest;
+    token: string;
+    user: any;
+}) => Promise<string> | string;
+type GenerateVerifyEmailSubject = (args: {
+    req: PayloadRequest;
+    token: string;
+    user: any;
+}) => Promise<string> | string;
+type GenerateForgotPasswordEmailHTML = (args?: {
+    req?: PayloadRequest;
+    token?: string;
+    user?: unknown;
+}) => Promise<string> | string;
+type GenerateForgotPasswordEmailSubject = (args?: {
+    req?: PayloadRequest;
+    token?: string;
+    user?: any;
+}) => Promise<string> | string;
+type AuthStrategy = ((ctx: Payload) => Strategy) | Strategy;
+export interface IncomingAuthType {
+    tokenExpiration?: number;
+    verify?: boolean | {
+        generateEmailHTML?: GenerateVerifyEmailHTML;
+        generateEmailSubject?: GenerateVerifyEmailSubject;
+    };
+    maxLoginAttempts?: number;
+    lockTime?: number;
+    useAPIKey?: boolean;
+    depth?: number;
+    cookies?: {
+        secure?: boolean;
+        sameSite?: boolean | 'none' | 'strict' | 'lax';
+        domain?: string;
+    };
+    forgotPassword?: {
+        generateEmailHTML?: GenerateForgotPasswordEmailHTML;
+        generateEmailSubject?: GenerateForgotPasswordEmailSubject;
+    };
+    disableLocalStrategy?: true;
+    strategies?: {
+        name?: string;
+        strategy: AuthStrategy;
+    }[];
+}
+export type VerifyConfig = {
+    generateEmailHTML?: GenerateVerifyEmailHTML;
+    generateEmailSubject?: GenerateVerifyEmailSubject;
+};
+export interface Auth extends Omit<DeepRequired<IncomingAuthType>, 'verify' | 'forgotPassword'> {
+    verify?: VerifyConfig | boolean;
+    forgotPassword?: {
+        generateEmailHTML?: GenerateForgotPasswordEmailHTML;
+        generateEmailSubject?: GenerateForgotPasswordEmailSubject;
+    };
+}
+export declare function hasWhereAccessResult(result: boolean | Where): result is Where;
+export {};

package/dist/auth/types.js

@@ -1,8 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasWhereAccessResult = void 0;
-function hasWhereAccessResult(result) {
-    return result && typeof result === 'object';
-}
-exports.hasWhereAccessResult = hasWhereAccessResult;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasWhereAccessResult = void 0;
+function hasWhereAccessResult(result) {
+    return result && typeof result === 'object';
+}
+exports.hasWhereAccessResult = hasWhereAccessResult;
 //# sourceMappingURL=types.js.map

package/dist/bin/build.d.ts

@@ -1 +1 @@
-export declare const build: () => Promise<void>;
+export declare const build: () => Promise<void>;

package/dist/bin/build.js

@@ -1,43 +1,43 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.build = void 0;
-/* eslint-disable @typescript-eslint/no-var-requires */
-/* eslint-disable global-require */
-const webpack_1 = __importDefault(require("webpack"));
-const getProdConfig_1 = __importDefault(require("../webpack/getProdConfig"));
-const find_1 = __importDefault(require("../config/find"));
-const load_1 = __importDefault(require("../config/load"));
-const rawConfigPath = (0, find_1.default)();
-const build = async () => {
-    try {
-        const config = await (0, load_1.default)();
-        const webpackProdConfig = (0, getProdConfig_1.default)(config);
-        (0, webpack_1.default)(webpackProdConfig, (err, stats) => {
-            if (err || stats.hasErrors()) {
-                // Handle errors here
-                if (stats) {
-                    console.error(stats.toString({
-                        chunks: false,
-                        colors: true,
-                    }));
-                }
-                else {
-                    console.error(err.message);
-                }
-            }
-        });
-    }
-    catch (err) {
-        console.error(err);
-        throw new Error(`Error: can't find the configuration file located at ${rawConfigPath}.`);
-    }
-};
-exports.build = build;
-// when build.js is launched directly
-if (module.id === require.main.id) {
-    (0, exports.build)();
-}
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build = void 0;
+/* eslint-disable @typescript-eslint/no-var-requires */
+/* eslint-disable global-require */
+const webpack_1 = __importDefault(require("webpack"));
+const getProdConfig_1 = __importDefault(require("../webpack/getProdConfig"));
+const find_1 = __importDefault(require("../config/find"));
+const load_1 = __importDefault(require("../config/load"));
+const rawConfigPath = (0, find_1.default)();
+const build = async () => {
+    try {
+        const config = await (0, load_1.default)();
+        const webpackProdConfig = (0, getProdConfig_1.default)(config);
+        (0, webpack_1.default)(webpackProdConfig, (err, stats) => {
+            if (err || stats.hasErrors()) {
+                // Handle errors here
+                if (stats) {
+                    console.error(stats.toString({
+                        chunks: false,
+                        colors: true,
+                    }));
+                }
+                else {
+                    console.error(err.message);
+                }
+            }
+        });
+    }
+    catch (err) {
+        console.error(err);
+        throw new Error(`Error: can't find the configuration file located at ${rawConfigPath}.`);
+    }
+};
+exports.build = build;
+// when build.js is launched directly
+if (module.id === require.main.id) {
+    (0, exports.build)();
+}
 //# sourceMappingURL=build.js.map

package/dist/bin/generateGraphQLSchema.d.ts

@@ -1 +1 @@
-export declare function generateGraphQLSchema(): Promise<void>;
+export declare function generateGraphQLSchema(): Promise<void>;

package/dist/bin/generateGraphQLSchema.js

@@ -1,30 +1,30 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateGraphQLSchema = void 0;
-/* eslint-disable no-nested-ternary */
-const fs_1 = __importDefault(require("fs"));
-const graphql_1 = require("graphql");
-const logger_1 = __importDefault(require("../utilities/logger"));
-const load_1 = __importDefault(require("../config/load"));
-const __1 = __importDefault(require(".."));
-async function generateGraphQLSchema() {
-    const logger = (0, logger_1.default)();
-    const config = await (0, load_1.default)();
-    await __1.default.init({
-        secret: '--unused--',
-        mongoURL: false,
-        local: true,
-    });
-    logger.info('Compiling GraphQL schema...');
-    fs_1.default.writeFileSync(config.graphQL.schemaOutputFile, (0, graphql_1.printSchema)(__1.default.schema));
-    logger.info(`GraphQL written to ${config.graphQL.schemaOutputFile}`);
-}
-exports.generateGraphQLSchema = generateGraphQLSchema;
-// when generateGraphQLSchema.js is launched directly
-if (module.id === require.main.id) {
-    generateGraphQLSchema();
-}
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateGraphQLSchema = void 0;
+/* eslint-disable no-nested-ternary */
+const fs_1 = __importDefault(require("fs"));
+const graphql_1 = require("graphql");
+const logger_1 = __importDefault(require("../utilities/logger"));
+const load_1 = __importDefault(require("../config/load"));
+const __1 = __importDefault(require(".."));
+async function generateGraphQLSchema() {
+    const logger = (0, logger_1.default)();
+    const config = await (0, load_1.default)();
+    await __1.default.init({
+        secret: '--unused--',
+        mongoURL: false,
+        local: true,
+    });
+    logger.info('Compiling GraphQL schema...');
+    fs_1.default.writeFileSync(config.graphQL.schemaOutputFile, (0, graphql_1.printSchema)(__1.default.schema));
+    logger.info(`GraphQL written to ${config.graphQL.schemaOutputFile}`);
+}
+exports.generateGraphQLSchema = generateGraphQLSchema;
+// when generateGraphQLSchema.js is launched directly
+if (module.id === require.main.id) {
+    generateGraphQLSchema();
+}
 //# sourceMappingURL=generateGraphQLSchema.js.map

package/dist/bin/generateTypes.d.ts

@@ -1 +1 @@
-export declare function generateTypes(): Promise<void>;
+export declare function generateTypes(): Promise<void>;