@nixxie-cms/core 1.0.0

package/fields/types/password/dist/nixxie-cms-core-fields-types-password.esm.js

@@ -0,0 +1,196 @@
+import bcryptjs from 'bcryptjs';
+import dumbPasswords from 'dumb-passwords';
+import { u as userInputError } from '../../../../dist/resolve-hooks-17aafd37.esm.js';
+import 'pluralize';
+import { g, f as fieldType } from '../../../../dist/next-fields-9bf04ed8.esm.js';
+import { m as makeValidateHook, d as defaultIsRequired } from '../../../../dist/non-null-graphql-5315718c.esm.js';
+import 'node:path';
+import '@graphql-ts/schema';
+import '@graphql-ts/extend';
+import { isObjectType } from 'graphql';
+import 'decimal.js';
+import 'graphql-upload/GraphQLUpload.js';
+
+const PasswordState = g.object()({
+  name: 'PasswordState',
+  fields: {
+    isSet: g.field({
+      type: g.nonNull(g.Boolean)
+    })
+  }
+});
+const PasswordFilter = g.inputObject({
+  name: 'PasswordFilter',
+  fields: {
+    isSet: g.arg({
+      type: g.nonNull(g.Boolean)
+    })
+  }
+});
+function password(config = {}) {
+  var _validation$length$mi, _validation$length, _validation$length2;
+  const {
+    kdf = {
+      hash: secret => {
+        // note this is slightly different to checking .length > 72 because
+        // bcrypt will truncate to 72 bytes after utf8 encoding
+        // not JS string length which may be different since that's the utf16 length
+        // (though using characters in the error message makes sense since users shouldn't have to think about bytes and it aligns with the validation messages below)
+        if (bcryptjs.truncates(secret)) throw new Error('value must be no longer than 72 characters');
+        return bcryptjs.hash(secret, 10);
+      },
+      compare: (secret, hash) => bcryptjs.compare(secret, hash)
+    },
+    validation = {}
+  } = config;
+  const {
+    isRequired = false,
+    rejectCommon = false,
+    match,
+    length: {
+      max
+    } = {}
+  } = validation;
+  const min = isRequired ? (_validation$length$mi = (_validation$length = validation.length) === null || _validation$length === void 0 ? void 0 : _validation$length.min) !== null && _validation$length$mi !== void 0 ? _validation$length$mi : 8 : (_validation$length2 = validation.length) === null || _validation$length2 === void 0 ? void 0 : _validation$length2.min;
+  return meta => {
+    var _config$db, _config$db2;
+    if (config.isIndexed === 'unique') {
+      throw Error("isIndexed: 'unique' is not a supported option for field type password");
+    }
+    if (min !== undefined && (!Number.isInteger(min) || min < 0)) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies validation.length.min: ${min} but it must be a positive integer`);
+    }
+    if (max !== undefined && (!Number.isInteger(max) || max < 0)) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies validation.length.max: ${max} but it must be a positive integer`);
+    }
+    if (isRequired && min !== undefined && min === 0) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies validation.isRequired: true and validation.length.min: 0, this is not allowed because validation.isRequired implies at least a min length of 1`);
+    }
+    if (isRequired && max !== undefined && max === 0) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies validation.isRequired: true and validation.length.max: 0, this is not allowed because validation.isRequired implies at least a max length of 1`);
+    }
+    if (min !== undefined && max !== undefined && min > max) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies a validation.length.max that is less than the validation.length.min, and therefore has no valid options`);
+    }
+    function inputResolver(val) {
+      if (val == null) return val;
+      return kdf.hash(val);
+    }
+    const hasAdditionalValidation = match || rejectCommon || min !== undefined || max !== undefined;
+    const {
+      mode,
+      validate
+    } = makeValidateHook(meta, config, hasAdditionalValidation ? ({
+      inputData,
+      operation,
+      addValidationError
+    }) => {
+      if (operation === 'delete') return;
+      const value = inputData[meta.fieldKey]; // we use inputData, as resolveData is hashed
+      if (value != null) {
+        if (min !== undefined && value.length < min) {
+          if (min === 1) {
+            addValidationError(`value must not be empty`);
+          } else {
+            addValidationError(`value must be at least ${min} characters long`);
+          }
+        }
+        if (max !== undefined && value.length > max) {
+          addValidationError(`value must be no longer than ${max} characters`);
+        }
+        if (match && !match.regex.test(value)) {
+          var _match$explanation;
+          addValidationError((_match$explanation = match.explanation) !== null && _match$explanation !== void 0 ? _match$explanation : `value must match ${match.regex}`);
+        }
+        if (rejectCommon && dumbPasswords.check(value)) {
+          addValidationError(`value is too common and is not allowed`);
+        }
+      }
+    } : undefined);
+    return fieldType({
+      kind: 'scalar',
+      scalar: 'String',
+      mode,
+      map: (_config$db = config.db) === null || _config$db === void 0 ? void 0 : _config$db.map,
+      extendPrismaSchema: (_config$db2 = config.db) === null || _config$db2 === void 0 ? void 0 : _config$db2.extendPrismaSchema
+    })({
+      ...config,
+      ...defaultIsRequired(config, isRequired),
+      hooks: {
+        ...config.hooks,
+        validate
+      },
+      input: {
+        where: mode === 'required' ? undefined : {
+          arg: g.arg({
+            type: PasswordFilter
+          }),
+          resolve(val) {
+            if (val === null) throw userInputError('Password filters cannot be set to null');
+            if (val.isSet) return {
+              not: null
+            };
+            return null;
+          }
+        },
+        create: {
+          arg: g.arg({
+            type: g.String
+          }),
+          resolve(val) {
+            if (val === undefined) return null;
+            return inputResolver(val);
+          }
+        },
+        update: {
+          arg: g.arg({
+            type: g.String
+          }),
+          resolve: inputResolver
+        }
+      },
+      __ksTelemetryFieldTypeName: '@nixxie-cms/password',
+      views: '@nixxie-cms/core/fields/types/password/views',
+      getAdminMeta: () => {
+        var _match$explanation2;
+        return {
+          isNullable: mode === 'optional',
+          validation: {
+            rejectCommon,
+            match: match ? {
+              regex: {
+                source: match.regex.source,
+                flags: match.regex.flags
+              },
+              explanation: (_match$explanation2 = match.explanation) !== null && _match$explanation2 !== void 0 ? _match$explanation2 : `value must match ${match.regex}`
+            } : null,
+            length: {
+              max: max !== null && max !== void 0 ? max : null,
+              min: min !== null && min !== void 0 ? min : 8
+            }
+          }
+        };
+      },
+      output: g.field({
+        type: PasswordState,
+        resolve(val) {
+          return {
+            isSet: val.value !== null
+          };
+        },
+        extensions: {
+          nixxieKDF: kdf
+        }
+      })
+    });
+  };
+}
+function getPasswordFieldKDF(schema, listKey, fieldKey) {
+  const gqlOutputType = schema.getType(listKey);
+  if (!isObjectType(gqlOutputType)) return null;
+  const passwordField = gqlOutputType.getFields()[fieldKey];
+  if (!(passwordField !== null && passwordField !== void 0 && passwordField.extensions.nixxieKDF)) return null;
+  return passwordField.extensions.nixxieKDF;
+}
+
+export { getPasswordFieldKDF, password };

package/fields/types/password/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "dist/nixxie-cms-core-fields-types-password.cjs.js",
+  "module": "dist/nixxie-cms-core-fields-types-password.esm.js"
+}

package/fields/types/password/views/dist/nixxie-cms-core-fields-types-password-views.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "../../../../../dist/declarations/src/fields/types/password/views/index.js";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibml4eGllLWNtcy1jb3JlLWZpZWxkcy10eXBlcy1wYXNzd29yZC12aWV3cy5janMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2Rpc3QvZGVjbGFyYXRpb25zL3NyYy9maWVsZHMvdHlwZXMvcGFzc3dvcmQvdmlld3MvaW5kZXguZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSJ9

package/fields/types/password/views/dist/nixxie-cms-core-fields-types-password-views.cjs.js

@@ -0,0 +1,330 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var dumbPasswords = require('dumb-passwords');
+var react = require('react');
+var utils = require('@react-aria/utils');
+var button = require('@keystar/ui/button');
+var checkbox = require('@keystar/ui/checkbox');
+var field = require('@keystar/ui/field');
+var icon = require('@keystar/ui/icon');
+var eyeIcon = require('@keystar/ui/icon/icons/eyeIcon');
+var asteriskIcon = require('@keystar/ui/icon/icons/asteriskIcon');
+var layout = require('@keystar/ui/layout');
+var style = require('@keystar/ui/style');
+var textField = require('@keystar/ui/text-field');
+var typography = require('@keystar/ui/typography');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var dumbPasswords__default = /*#__PURE__*/_interopDefault(dumbPasswords);
+
+// @ts-expect-error
+function validate(value, validation, isRequired, fieldLabel) {
+  if (value.kind === 'initial' && (value.isSet === null || value.isSet === true)) {
+    return undefined;
+  }
+  if (value.kind === 'initial' && isRequired) {
+    return `${fieldLabel} is required`;
+  }
+  if (value.kind === 'editing' && value.confirm !== value.value) {
+    return `The passwords do not match`;
+  }
+  if (value.kind === 'editing') {
+    const val = value.value;
+    if (val.length < validation.length.min) {
+      if (validation.length.min === 1) {
+        return `${fieldLabel} must not be empty`;
+      }
+      return `${fieldLabel} must be at least ${validation.length.min} characters long`;
+    }
+    if (validation.length.max !== null && val.length > validation.length.max) {
+      return `${fieldLabel} must be no longer than ${validation.length.max} characters`;
+    }
+    if (validation.match && !validation.match.regex.test(val)) {
+      return validation.match.explanation;
+    }
+    if (validation.rejectCommon && dumbPasswords__default["default"].check(val)) {
+      return `${fieldLabel} is too common and is not allowed`;
+    }
+  }
+  return undefined;
+}
+function readonlyCheckboxProps(isSet) {
+  const isIndeterminate = isSet == null;
+  const isSelected = isSet == null ? undefined : isSet;
+  return {
+    children: isIndeterminate ? 'Access denied' : 'Value is set',
+    isIndeterminate,
+    isReadOnly: true,
+    isSelected,
+    prominence: 'low'
+  };
+}
+function Field(props) {
+  const {
+    autoFocus,
+    field: field$1,
+    forceValidation,
+    onChange,
+    value
+  } = props;
+  const [secureTextEntry, setSecureTextEntry] = react.useState(true);
+  const [touched, setTouched] = react.useState({
+    value: false,
+    confirm: false
+  });
+  const triggerRef = react.useRef(null);
+  const isReadOnly = onChange == null;
+  const validationMessage = forceValidation || touched.value && touched.confirm ? validate(value, field$1.validation, props.isRequired, field$1.label) : undefined;
+  const labelId = react.useId();
+  const descriptionId = utils.useSlotId([!!field$1.description, !!validationMessage]);
+  const messageId = utils.useSlotId([!!field$1.description, !!validationMessage]);
+  const cancelEditing = () => {
+    onChange === null || onChange === void 0 || onChange({
+      kind: 'initial',
+      isSet: value.isSet
+    });
+    setTimeout(() => {
+      var _triggerRef$current;
+      (_triggerRef$current = triggerRef.current) === null || _triggerRef$current === void 0 || _triggerRef$current.focus();
+    }, 0);
+  };
+  const onEscape = e => {
+    if (e.key !== 'Escape' || value.kind !== 'editing') return;
+    if (value.value === '' && value.confirm === '') {
+      cancelEditing();
+    }
+  };
+
+  // reset when the user cancels, or when the form is submitted
+  react.useEffect(() => {
+    if (value.kind === 'initial') {
+      setTouched({
+        value: false,
+        confirm: false
+      });
+      setSecureTextEntry(true);
+    }
+  }, [value.kind]);
+  return /*#__PURE__*/jsxRuntime.jsxs(layout.VStack, {
+    role: "group",
+    "aria-labelledby": labelId,
+    "aria-describedby": descriptionId,
+    gap: "medium",
+    minWidth: 0,
+    children: [/*#__PURE__*/jsxRuntime.jsx(field.FieldLabel, {
+      elementType: "span",
+      id: labelId,
+      children: field$1.label
+    }), !!field$1.description && /*#__PURE__*/jsxRuntime.jsx(typography.Text, {
+      id: descriptionId,
+      size: "regular",
+      color: "neutralSecondary",
+      children: field$1.description
+    }), isReadOnly ? /*#__PURE__*/jsxRuntime.jsx(checkbox.Checkbox, {
+      ...readonlyCheckboxProps(value.isSet)
+    }) : value.kind === 'initial' ? /*#__PURE__*/jsxRuntime.jsxs(button.ActionButton, {
+      ref: triggerRef,
+      alignSelf: "start",
+      autoFocus: autoFocus,
+      onPress: () => {
+        onChange({
+          kind: 'editing',
+          confirm: '',
+          value: '',
+          isSet: value.isSet
+        });
+      },
+      children: [value.isSet ? `Change ` : `Set `, field$1.label.toLocaleLowerCase()]
+    }) : /*#__PURE__*/jsxRuntime.jsxs(layout.Flex, {
+      gap: "regular",
+      UNSAFE_className: style.css({
+        [style.containerQueries.below.tablet]: {
+          flexDirection: 'column'
+        }
+      }),
+      children: [/*#__PURE__*/jsxRuntime.jsx(textField.TextField, {
+        autoFocus: true,
+        "aria-label": `new ${field$1.label}`,
+        "aria-describedby": [descriptionId, messageId].filter(Boolean).join(' ')
+        // @ts-expect-error — needs to be fixed in "@keystar/ui"
+        ,
+        isInvalid: !!validationMessage,
+        onBlur: () => setTouched({
+          ...touched,
+          value: true
+        }),
+        onChange: text => onChange({
+          ...value,
+          value: text
+        }),
+        onKeyDown: onEscape,
+        placeholder: "New",
+        type: secureTextEntry ? 'password' : 'text',
+        value: value.value,
+        flex: true
+      }), /*#__PURE__*/jsxRuntime.jsx(textField.TextField, {
+        "aria-label": `confirm ${field$1.label}`,
+        "aria-describedby": messageId // don't repeat the description announcement for the confirm field
+        // @ts-expect-error — needs to be fixed in "@keystar/ui"
+        ,
+        isInvalid: !!validationMessage,
+        onBlur: () => setTouched({
+          ...touched,
+          confirm: true
+        }),
+        onChange: text => onChange({
+          ...value,
+          confirm: text
+        }),
+        onKeyDown: onEscape,
+        placeholder: "Confirm",
+        type: secureTextEntry ? 'password' : 'text',
+        value: value.confirm,
+        flex: true
+      }), /*#__PURE__*/jsxRuntime.jsxs(layout.Flex, {
+        gap: "regular",
+        children: [/*#__PURE__*/jsxRuntime.jsxs(button.ToggleButton, {
+          "aria-label": "show",
+          isSelected: !secureTextEntry,
+          onPress: () => setSecureTextEntry(bool => !bool),
+          children: [/*#__PURE__*/jsxRuntime.jsx(icon.Icon, {
+            src: eyeIcon.eyeIcon
+          }), /*#__PURE__*/jsxRuntime.jsx(typography.Text, {
+            UNSAFE_className: style.css({
+              [style.containerQueries.above.mobile]: {
+                display: 'none'
+              }
+            }),
+            children: "Show"
+          })]
+        }), /*#__PURE__*/jsxRuntime.jsx(button.ActionButton, {
+          onPress: cancelEditing,
+          children: "Cancel"
+        })]
+      })]
+    }), !!validationMessage && /*#__PURE__*/jsxRuntime.jsx(field.FieldMessage, {
+      id: messageId,
+      children: validationMessage
+    })]
+  });
+}
+const Cell = ({
+  value
+}) => {
+  return value !== null ? /*#__PURE__*/jsxRuntime.jsxs("div", {
+    "aria-label": "is set",
+    style: {
+      display: 'flex'
+    },
+    children: [/*#__PURE__*/jsxRuntime.jsx(icon.Icon, {
+      src: asteriskIcon.asteriskIcon,
+      size: "small"
+    }), /*#__PURE__*/jsxRuntime.jsx(icon.Icon, {
+      src: asteriskIcon.asteriskIcon,
+      size: "small"
+    }), /*#__PURE__*/jsxRuntime.jsx(icon.Icon, {
+      src: asteriskIcon.asteriskIcon,
+      size: "small"
+    })]
+  }) : /*#__PURE__*/jsxRuntime.jsx(typography.VisuallyHidden, {
+    children: "not set"
+  });
+};
+function controller(config) {
+  const validation = {
+    ...config.fieldMeta.validation,
+    match: config.fieldMeta.validation.match === null ? null : {
+      regex: new RegExp(config.fieldMeta.validation.match.regex.source, config.fieldMeta.validation.match.regex.flags),
+      explanation: config.fieldMeta.validation.match.explanation
+    }
+  };
+  return {
+    fieldKey: config.fieldKey,
+    label: config.label,
+    description: config.description,
+    graphqlSelection: `${config.fieldKey} {isSet}`,
+    validation,
+    defaultValue: {
+      kind: 'initial',
+      isSet: false
+    },
+    validate: (state, opts) => validate(state, validation, opts.isRequired, config.label) === undefined,
+    deserialize: data => {
+      var _data$config$fieldKey, _data$config$fieldKey2;
+      return {
+        kind: 'initial',
+        isSet: (_data$config$fieldKey = (_data$config$fieldKey2 = data[config.fieldKey]) === null || _data$config$fieldKey2 === void 0 ? void 0 : _data$config$fieldKey2.isSet) !== null && _data$config$fieldKey !== void 0 ? _data$config$fieldKey : null
+      };
+    },
+    serialize: value => {
+      if (value.kind === 'initial') return {};
+      return {
+        [config.fieldKey]: value.value
+      };
+    },
+    filter: config.fieldMeta.isNullable === false ? undefined : {
+      Filter(props) {
+        const {
+          autoFocus,
+          context,
+          typeLabel,
+          onChange,
+          value,
+          type,
+          ...otherProps
+        } = props;
+        return /*#__PURE__*/jsxRuntime.jsxs(checkbox.Checkbox, {
+          autoFocus: autoFocus,
+          onChange: onChange,
+          isSelected: value !== null && value !== void 0 ? value : false,
+          ...otherProps,
+          children: [typeLabel, " set"]
+        });
+      },
+      graphql({
+        type,
+        value
+      }) {
+        return {
+          [config.fieldKey]: {
+            isSet: type === 'not' ? !value : value
+          }
+        };
+      },
+      parseGraphQL: value => {
+        if ((value === null || value === void 0 ? void 0 : value.isSet) !== undefined) {
+          return [{
+            type: 'is',
+            value: value.isSet
+          }];
+        }
+        return [];
+      },
+      Label({
+        type,
+        value
+      }) {
+        if (type === 'is' && value || type === 'not' && !value) return `is set`;
+        return `is not set`;
+      },
+      types: {
+        is: {
+          label: 'Is',
+          initialValue: true
+        },
+        not: {
+          label: 'Is not',
+          initialValue: true
+        }
+      }
+    }
+  };
+}
+
+exports.Cell = Cell;
+exports.Field = Field;
+exports.controller = controller;