@nixxie-cms/core 1.0.0

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

@@ -0,0 +1,1785 @@
+import { u as userInputError, a as merge } from '../../dist/resolve-hooks-17aafd37.esm.js';
+import 'pluralize';
+import { f as fieldType, g, o as orderDirectionEnum } from '../../dist/next-fields-9bf04ed8.esm.js';
+import { f as filters, a as resolveCommon, b as resolveString } from '../../dist/index-24b78415.esm.js';
+export { r as relationship, t as timestamp } from '../../dist/index-24b78415.esm.js';
+import { a as assertReadIsNonNullAllowed, m as makeValidateHook, d as defaultIsRequired, r as resolveDbNullable } from '../../dist/non-null-graphql-5315718c.esm.js';
+import 'node:path';
+import { GNonNull } from '@graphql-ts/schema';
+import '@graphql-ts/extend';
+import Decimal from 'decimal.js';
+import { randomBytes } from 'node:crypto';
+import { SUPPORTED_IMAGE_EXTENSIONS } from '../types/image/utils/dist/nixxie-cms-core-fields-types-image-utils.esm.js';
+import { JPG } from 'image-size/types/jpg';
+import { PNG } from 'image-size/types/png';
+import { WEBP } from 'image-size/types/webp';
+import { GIF } from 'image-size/types/gif';
+import { PassThrough } from 'node:stream';
+export { password } from '../types/password/dist/nixxie-cms-core-fields-types-password.esm.js';
+import { h as humanize } from '../../dist/utils-0cc426c8.esm.js';
+import { getNamedType, isLeafType } from 'graphql';
+export { bytes } from '../types/bytes/dist/nixxie-cms-core-fields-types-bytes.esm.js';
+import 'graphql-upload/GraphQLUpload.js';
+import '../../dist/admin-meta-14c60fec.esm.js';
+import 'bcryptjs';
+import 'dumb-passwords';
+import '../../dist/utils-f9556354.esm.js';
+
+function checkbox(config = {}) {
+  const {
+    defaultValue = false
+  } = config;
+  return meta => {
+    var _config$db, _config$db2;
+    if (config.isIndexed === 'unique') {
+      throw TypeError("isIndexed: 'unique' is not a supported option for field type checkbox");
+    }
+    assertReadIsNonNullAllowed(meta, config, false);
+    return fieldType({
+      kind: 'scalar',
+      mode: 'required',
+      scalar: 'Boolean',
+      default: {
+        kind: 'literal',
+        value: defaultValue
+      },
+      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,
+      input: {
+        where: {
+          arg: g.arg({
+            type: filters[meta.provider].Boolean.required
+          })
+        },
+        create: {
+          arg: g.arg({
+            type: g.Boolean,
+            defaultValue: typeof defaultValue === 'boolean' ? defaultValue : undefined
+          }),
+          resolve(val) {
+            if (val === null) throw userInputError('Checkbox fields cannot be set to null');
+            return val !== null && val !== void 0 ? val : defaultValue;
+          }
+        },
+        update: {
+          arg: g.arg({
+            type: g.Boolean
+          }),
+          resolve(val) {
+            if (val === null) throw userInputError('Checkbox fields cannot be set to null');
+            return val;
+          }
+        },
+        orderBy: {
+          arg: g.arg({
+            type: orderDirectionEnum
+          })
+        }
+      },
+      output: g.field({
+        type: g.Boolean
+      }),
+      __ksTelemetryFieldTypeName: '@nixxie-cms/checkbox',
+      views: '@nixxie-cms/core/fields/types/checkbox/views',
+      getAdminMeta: () => ({
+        defaultValue
+      })
+    });
+  };
+}
+
+function safeParseDecimal(value) {
+  if (value === null || value === undefined) return value;
+  const result = new Decimal(value);
+  if (!result.isFinite()) throw new Error(`"${value}" is not finite`);
+  return result;
+}
+
+// TODO: https://github.com/Nixxie/keystatic/blob/main/design-system/pkg/src/number-field/NumberField.tsx
+function decimal(config = {}) {
+  var _safeParseDecimal, _safeParseDecimal2;
+  const {
+    defaultValue: defaultValue_,
+    isIndexed,
+    precision = 18,
+    scale = 4,
+    validation = {}
+  } = config;
+  const {
+    isRequired = false,
+    min,
+    max
+  } = validation;
+  const defaultValue = typeof defaultValue_ === 'string' ? defaultValue_ : null;
+  const parsedDefaultValue = safeParseDecimal(defaultValue);
+  const parsedMax = (_safeParseDecimal = safeParseDecimal(max)) !== null && _safeParseDecimal !== void 0 ? _safeParseDecimal : undefined;
+  const parsedMin = (_safeParseDecimal2 = safeParseDecimal(min)) !== null && _safeParseDecimal2 !== void 0 ? _safeParseDecimal2 : undefined;
+  return meta => {
+    var _config$db, _config$db2;
+    if (meta.provider === 'sqlite') {
+      throw new Error('The decimal field does not support sqlite');
+    }
+    if (!Number.isInteger(scale)) {
+      throw new TypeError(`The scale for decimal fields must be an integer but the scale for the decimal field at ${meta.listKey}.${meta.fieldKey} is not an integer`);
+    }
+    if (!Number.isInteger(precision)) {
+      throw new TypeError(`The precision for decimal fields must be an integer but the precision for the decimal field at ${meta.listKey}.${meta.fieldKey} is not an integer`);
+    }
+    if (scale > precision) {
+      throw new Error(`The scale configured for decimal field at ${meta.listKey}.${meta.fieldKey} (${scale}) ` + `must not be larger than the field's precision (${precision})`);
+    }
+    if (defaultValue !== null && !parsedDefaultValue) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies a default value of: ${defaultValue} but it must be a valid finite number`);
+    }
+    if (min !== undefined && !parsedMin) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies validation.min: ${min} but it must be a valid finite number`);
+    }
+    if (max !== undefined && !parsedMax) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies validation.max: ${max} but it must be a valid finite number`);
+    }
+    if (min !== undefined && max !== undefined && parsedMin && parsedMax && parsedMin > parsedMax) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies a validation.max that is less than the validation.min, and therefore has no valid options`);
+    }
+    const hasAdditionalValidation = min !== undefined || max !== undefined;
+    const {
+      mode,
+      validate
+    } = makeValidateHook(meta, config, hasAdditionalValidation ? ({
+      resolvedData,
+      operation,
+      addValidationError
+    }) => {
+      if (operation === 'delete') return;
+      const value = safeParseDecimal(resolvedData[meta.fieldKey]);
+      if (value != null) {
+        if (parsedMin !== undefined && value.lessThan(parsedMin)) {
+          addValidationError(`value must be greater than or equal to ${min}`);
+        }
+        if (parsedMax !== undefined && value.greaterThan(parsedMax)) {
+          addValidationError(`value must be less than or equal to ${max}`);
+        }
+      }
+    } : undefined);
+    return fieldType({
+      kind: 'scalar',
+      mode,
+      scalar: 'Decimal',
+      nativeType: `Decimal(${precision}, ${scale})`,
+      index: isIndexed === true ? 'index' : isIndexed || undefined,
+      default: typeof defaultValue === 'string' ? {
+        kind: 'literal',
+        value: defaultValue
+      } : undefined,
+      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: {
+        uniqueWhere: isIndexed === 'unique' ? {
+          arg: g.arg({
+            type: g.Decimal
+          })
+        } : undefined,
+        where: {
+          arg: g.arg({
+            type: filters[meta.provider].Decimal[mode]
+          }),
+          resolve: mode === 'optional' ? resolveCommon : undefined
+        },
+        create: {
+          arg: g.arg({
+            type: g.Decimal,
+            defaultValue: parsedDefaultValue
+          }),
+          resolve(val) {
+            if (val === undefined) return parsedDefaultValue;
+            return val;
+          }
+        },
+        update: {
+          arg: g.arg({
+            type: g.Decimal
+          })
+        },
+        orderBy: {
+          arg: g.arg({
+            type: orderDirectionEnum
+          })
+        }
+      },
+      output: g.field({
+        type: g.Decimal,
+        resolve({
+          value
+        }) {
+          if (value === null) return null;
+          const val = new Decimal(value);
+          val.scaleToPrint = scale;
+          return val;
+        }
+      }),
+      __ksTelemetryFieldTypeName: '@nixxie-cms/decimal',
+      views: '@nixxie-cms/core/fields/types/decimal/views',
+      getAdminMeta() {
+        return {
+          validation: {
+            max: max !== null && max !== void 0 ? max : null,
+            min: min !== null && min !== void 0 ? min : null
+          },
+          defaultValue
+        };
+      }
+    });
+  };
+}
+
+const FileFieldInput = g.inputObject({
+  name: 'FileFieldInput',
+  fields: {
+    upload: g.arg({
+      type: g.nonNull(g.Upload)
+    })
+  }
+});
+const inputArg$1 = g.arg({
+  type: FileFieldInput
+});
+const FileFieldOutput = g.object()({
+  name: 'FileFieldOutput',
+  fields: {
+    filename: g.field({
+      type: g.nonNull(g.String)
+    }),
+    filesize: g.field({
+      type: g.nonNull(g.Int)
+    }),
+    url: g.field({
+      type: g.nonNull(g.String)
+    })
+  }
+});
+async function inputResolver$1(storage, transformName, context, data) {
+  if (data === null || data === undefined) return {
+    filename: data,
+    filesize: data
+  };
+  const upload = await data.upload;
+  const stream = upload.createReadStream();
+  let filesize = 0;
+  stream.on('data', data => {
+    filesize += data.length;
+  });
+  const filename = await transformName(upload.filename);
+  await storage.put(filename, stream, {
+    contentType: 'application/octet-stream'
+  }, context);
+  return {
+    filename,
+    filesize
+  };
+}
+function file(config) {
+  const {
+    transformName = defaultTransformName$1
+  } = config;
+  return meta => {
+    var _config$db, _config$hooks;
+    const {
+      fieldKey
+    } = meta;
+    if ('isIndexed' in config) {
+      throw Error("isIndexed: 'unique' is not a supported option for field type file");
+    }
+    const afterOperationResolver = async function afterOperationResolver(args) {
+      if (args.operation === 'update' || args.operation === 'delete') {
+        var _args$item;
+        const filenameKey = `${fieldKey}_filename`;
+        const oldFilename = args.originalItem[filenameKey];
+        const newFilename = (_args$item = args.item) === null || _args$item === void 0 ? void 0 : _args$item[filenameKey];
+
+        // this will occur on an update where a file already existed but has been
+        // changed, or on a delete, where there is no longer an item
+        // but not when the old and new filenames are the same (in that case, presumably the file has been overwritten)
+        if (typeof oldFilename === 'string' && oldFilename !== newFilename) {
+          await config.storage.delete(oldFilename, args.context);
+        }
+      }
+    };
+    return fieldType({
+      kind: 'multi',
+      extendPrismaSchema: (_config$db = config.db) === null || _config$db === void 0 ? void 0 : _config$db.extendPrismaSchema,
+      fields: {
+        filesize: {
+          kind: 'scalar',
+          scalar: 'Int',
+          mode: 'optional'
+        },
+        filename: {
+          kind: 'scalar',
+          scalar: 'String',
+          mode: 'optional'
+        }
+      }
+    })({
+      ...config,
+      hooks: {
+        ...config.hooks,
+        afterOperation: merge((_config$hooks = config.hooks) === null || _config$hooks === void 0 ? void 0 : _config$hooks.afterOperation, {
+          update: afterOperationResolver,
+          delete: afterOperationResolver
+        })
+      },
+      input: {
+        create: {
+          arg: inputArg$1,
+          resolve: (data, context) => inputResolver$1(config.storage, transformName, context, data)
+        },
+        update: {
+          arg: inputArg$1,
+          resolve: (data, context) => inputResolver$1(config.storage, transformName, context, data)
+        }
+      },
+      output: g.field({
+        type: FileFieldOutput,
+        resolve({
+          value: {
+            filesize,
+            filename
+          }
+        }) {
+          if (filename === null) return null;
+          if (filesize === null) return null;
+          return {
+            filename,
+            filesize,
+            url: async (_, context) => config.storage.url(filename, context)
+          };
+        }
+      }),
+      __ksTelemetryFieldTypeName: '@nixxie-cms/file',
+      views: '@nixxie-cms/core/fields/types/file/views'
+    });
+  };
+}
+
+// appends a 128-bit random identifier to the filename to prevent guessing
+function defaultTransformName$1(path) {
+  // this regex lazily matches for any characters that aren't a new line
+  // it then optionally matches the last instance of a "." symbol
+  // followed by any alphanumerical character before the end of the string
+  const [, name, ext] = path.match(/^([^:\n].*?)(\.[A-Za-z0-9]{0,10})?$/);
+  const id = randomBytes(16).toString('base64url');
+  const urlSafeName = name.replace(/[^A-Za-z0-9]/g, '-');
+  if (ext) return `${urlSafeName}-${id}${ext}`;
+  return `${urlSafeName}-${id}`;
+}
+
+function float(config = {}) {
+  const {
+    defaultValue: defaultValue_,
+    isIndexed,
+    validation = {}
+  } = config;
+  const {
+    isRequired = false,
+    min,
+    max
+  } = validation;
+  const defaultValue = defaultValue_ !== null && defaultValue_ !== void 0 ? defaultValue_ : null;
+  return meta => {
+    var _config$db, _config$db2;
+    if (defaultValue !== null && !Number.isFinite(defaultValue)) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies a default value of: ${defaultValue} but it must be a valid finite number`);
+    }
+    if (min !== undefined && !Number.isFinite(min)) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies validation.min: ${min} but it must be a valid finite number`);
+    }
+    if (max !== undefined && !Number.isFinite(max)) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies validation.max: ${max} but it must be a valid finite number`);
+    }
+    if (min !== undefined && max !== undefined && min > max) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies a validation.max that is less than the validation.min, and therefore has no valid options`);
+    }
+    const hasAdditionalValidation = min !== undefined || max !== undefined;
+    const {
+      mode,
+      validate
+    } = makeValidateHook(meta, config, hasAdditionalValidation ? ({
+      resolvedData,
+      operation,
+      addValidationError
+    }) => {
+      if (operation === 'delete') return;
+      const value = resolvedData[meta.fieldKey];
+      if (typeof value === 'number') {
+        if (min !== undefined && value < min) {
+          addValidationError(`value must be greater than or equal to ${min}`);
+        }
+        if (max !== undefined && value > max) {
+          addValidationError(`value must be less than or equal to ${max}`);
+        }
+      }
+    } : undefined);
+    return fieldType({
+      kind: 'scalar',
+      mode,
+      scalar: 'Float',
+      index: isIndexed === true ? 'index' : isIndexed || undefined,
+      default: typeof defaultValue === 'number' ? {
+        kind: 'literal',
+        value: defaultValue
+      } : undefined,
+      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: {
+        uniqueWhere: isIndexed === 'unique' ? {
+          arg: g.arg({
+            type: g.Float
+          })
+        } : undefined,
+        where: {
+          arg: g.arg({
+            type: filters[meta.provider].Float[mode]
+          }),
+          resolve: mode === 'optional' ? resolveCommon : undefined
+        },
+        create: {
+          arg: g.arg({
+            type: g.Float,
+            defaultValue: typeof defaultValue === 'number' ? defaultValue : undefined
+          }),
+          resolve(value) {
+            if (value === undefined) return defaultValue;
+            return value;
+          }
+        },
+        update: {
+          arg: g.arg({
+            type: g.Float
+          })
+        },
+        orderBy: {
+          arg: g.arg({
+            type: orderDirectionEnum
+          })
+        }
+      },
+      output: g.field({
+        type: g.Float
+      }),
+      __ksTelemetryFieldTypeName: '@nixxie-cms/float',
+      views: '@nixxie-cms/core/fields/types/float/views',
+      getAdminMeta() {
+        return {
+          validation: {
+            min: min !== null && min !== void 0 ? min : null,
+            max: max !== null && max !== void 0 ? max : null
+          },
+          defaultValue: defaultValue === null ? null : defaultValue.toString()
+        };
+      }
+    });
+  };
+}
+
+// for a signed 32-bit integer
+const MAX_INT$3 = 0x7fffffff;
+const MIN_INT$3 = -0x80000000;
+function integer(config = {}) {
+  var _defaultValue_$kind;
+  const {
+    defaultValue: defaultValue_,
+    isIndexed,
+    validation = {}
+  } = config;
+  const {
+    isRequired = false,
+    min,
+    max
+  } = validation;
+  const defaultValue = typeof defaultValue_ === 'number' ? defaultValue_ : (_defaultValue_$kind = defaultValue_ === null || defaultValue_ === void 0 ? void 0 : defaultValue_.kind) !== null && _defaultValue_$kind !== void 0 ? _defaultValue_$kind : null;
+  return meta => {
+    var _config$db, _config$db2;
+    if (typeof defaultValue === 'number' && !Number.isInteger(defaultValue)) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies a default value of: ${defaultValue} but it must be a valid finite number`);
+    }
+    if (min !== undefined && !Number.isInteger(min)) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies validation.min: ${min} but it must be an integer`);
+    }
+    if (max !== undefined && !Number.isInteger(max)) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies validation.max: ${max} but it must be an integer`);
+    }
+    if (min !== undefined && (min > MAX_INT$3 || min < MIN_INT$3)) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies validation.min: ${min} which is outside of the range of a 32-bit signed integer`);
+    }
+    if (max !== undefined && (max > MAX_INT$3 || max < MIN_INT$3)) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies validation.max: ${max} which is outside of the range of a 32-bit signed integer`);
+    }
+    if (min !== undefined && max !== undefined && min > max) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies a validation.max that is less than the validation.min, and therefore has no valid options`);
+    }
+    const hasAdditionalValidation = min !== undefined || max !== undefined;
+    const {
+      mode,
+      validate
+    } = makeValidateHook(meta, config, hasAdditionalValidation ? ({
+      resolvedData,
+      operation,
+      addValidationError
+    }) => {
+      if (operation === 'delete') return;
+      const value = resolvedData[meta.fieldKey];
+      if (typeof value === 'number') {
+        if (min !== undefined && value < min) {
+          addValidationError(`value must be greater than or equal to ${min}`);
+        }
+        if (max !== undefined && value > max) {
+          addValidationError(`value must be less than or equal to ${max}`);
+        }
+      }
+    } : undefined, defaultValue !== null);
+    return fieldType({
+      kind: 'scalar',
+      mode,
+      scalar: 'Int',
+      index: isIndexed === true ? 'index' : isIndexed || undefined,
+      default: typeof defaultValue === 'number' ? {
+        kind: 'literal',
+        value: defaultValue
+      } : defaultValue === 'autoincrement' ? {
+        kind: 'autoincrement'
+      } : undefined,
+      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: {
+        uniqueWhere: isIndexed === 'unique' ? {
+          arg: g.arg({
+            type: g.Int
+          })
+        } : undefined,
+        where: {
+          arg: g.arg({
+            type: filters[meta.provider].Int[mode]
+          }),
+          resolve: mode === 'optional' ? resolveCommon : undefined
+        },
+        create: {
+          arg: g.arg({
+            type: g.Int,
+            defaultValue: typeof defaultValue === 'number' ? defaultValue : undefined
+          }),
+          resolve(value) {
+            if (value === undefined) {
+              if (defaultValue === 'autoincrement') return undefined;
+              return defaultValue;
+            }
+            return value;
+          }
+        },
+        update: {
+          arg: g.arg({
+            type: g.Int
+          })
+        },
+        orderBy: {
+          arg: g.arg({
+            type: orderDirectionEnum
+          })
+        }
+      },
+      output: g.field({
+        type: g.Int
+      }),
+      __ksTelemetryFieldTypeName: '@nixxie-cms/integer',
+      views: '@nixxie-cms/core/fields/types/integer/views',
+      getAdminMeta() {
+        return {
+          validation: {
+            min: min !== null && min !== void 0 ? min : MIN_INT$3,
+            max: max !== null && max !== void 0 ? max : MAX_INT$3
+          },
+          defaultValue
+        };
+      }
+    });
+  };
+}
+
+// for a signed 64-bit integer
+const MAX_INT$2 = 9223372036854775807n;
+const MIN_INT$2 = -9223372036854775808n;
+
+// TODO: https://github.com/Nixxie/keystatic/blob/main/design-system/pkg/src/number-field/NumberField.tsx
+function bigInt(config = {}) {
+  var _defaultValue_$kind;
+  const {
+    defaultValue: defaultValue_ = null,
+    isIndexed,
+    validation = {}
+  } = config;
+  const {
+    isRequired = false,
+    min,
+    max
+  } = validation;
+  const defaultValue = typeof defaultValue_ === 'bigint' ? defaultValue_ : (_defaultValue_$kind = defaultValue_ === null || defaultValue_ === void 0 ? void 0 : defaultValue_.kind) !== null && _defaultValue_$kind !== void 0 ? _defaultValue_$kind : null;
+  return meta => {
+    var _config$db, _config$db2;
+    if (defaultValue === 'autoincrement') {
+      if (meta.provider === 'sqlite' || meta.provider === 'mysql') {
+        throw new Error(`${meta.listKey}.${meta.fieldKey} specifies defaultValue: { kind: 'autoincrement' }, this is not supported on ${meta.provider}`);
+      }
+      const isNullable = resolveDbNullable(validation, config.db);
+      if (isNullable !== false) {
+        throw new Error(`${meta.listKey}.${meta.fieldKey} specifies defaultValue: { kind: 'autoincrement' } but doesn't specify db.isNullable: false.\n` + `Having nullable autoincrements on Prisma currently incorrectly creates a non-nullable column so it is not allowed.\n` + `https://github.com/prisma/prisma/issues/8663`);
+      }
+      if (isRequired) {
+        throw new Error(`${meta.listKey}.${meta.fieldKey} defaultValue: { kind: 'autoincrement' } conflicts with validation.isRequired: true`);
+      }
+    }
+    if (
+    // TODO: prefer typescript only?
+    defaultValue !== null && defaultValue !== 'autoincrement' && typeof defaultValue !== 'bigint') {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies a default value of: ${defaultValue} but it must be a valid finite number`);
+    }
+    if (min !== undefined && !Number.isInteger(min)) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies validation.min: ${min} but it must be an integer`);
+    }
+    if (max !== undefined && !Number.isInteger(max)) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies validation.max: ${max} but it must be an integer`);
+    }
+    if (min !== undefined && (min > MAX_INT$2 || min < MIN_INT$2)) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies validation.min: ${min} which is outside of the range of a 64-bit signed integer`);
+    }
+    if (max !== undefined && (max > MAX_INT$2 || max < MIN_INT$2)) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies validation.max: ${max} which is outside of the range of a 64-bit signed integer`);
+    }
+    if (min !== undefined && max !== undefined && min > max) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies a validation.max that is less than the validation.min, and therefore has no valid options`);
+    }
+    const hasAdditionalValidation = min !== undefined || max !== undefined;
+    const {
+      mode,
+      validate
+    } = makeValidateHook(meta, config, hasAdditionalValidation ? ({
+      resolvedData,
+      operation,
+      addValidationError
+    }) => {
+      if (operation === 'delete') return;
+      const value = resolvedData[meta.fieldKey];
+      if (typeof value === 'number') {
+        if (min !== undefined && value < min) {
+          addValidationError(`value must be greater than or equal to ${min}`);
+        }
+        if (max !== undefined && value > max) {
+          addValidationError(`value must be less than or equal to ${max}`);
+        }
+      }
+    } : undefined);
+    return fieldType({
+      kind: 'scalar',
+      mode,
+      scalar: 'BigInt',
+      index: isIndexed === true ? 'index' : isIndexed || undefined,
+      default: typeof defaultValue === 'bigint' ? {
+        kind: 'literal',
+        value: defaultValue
+      } : defaultValue === 'autoincrement' ? {
+        kind: 'autoincrement'
+      } : undefined,
+      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: {
+        uniqueWhere: isIndexed === 'unique' ? {
+          arg: g.arg({
+            type: g.BigInt
+          })
+        } : undefined,
+        where: {
+          arg: g.arg({
+            type: filters[meta.provider].BigInt[mode]
+          }),
+          resolve: mode === 'optional' ? resolveCommon : undefined
+        },
+        create: {
+          arg: g.arg({
+            type: g.BigInt,
+            defaultValue: typeof defaultValue === 'bigint' ? defaultValue : undefined
+          }),
+          resolve(value) {
+            if (value === undefined) {
+              if (defaultValue === 'autoincrement') return null;
+              return defaultValue;
+            }
+            return value;
+          }
+        },
+        update: {
+          arg: g.arg({
+            type: g.BigInt
+          })
+        },
+        orderBy: {
+          arg: g.arg({
+            type: orderDirectionEnum
+          })
+        }
+      },
+      output: g.field({
+        type: g.BigInt
+      }),
+      __ksTelemetryFieldTypeName: '@nixxie-cms/bigInt',
+      views: '@nixxie-cms/core/fields/types/bigInt/views',
+      getAdminMeta() {
+        var _min$toString, _max$toString;
+        return {
+          validation: {
+            min: (_min$toString = min === null || min === void 0 ? void 0 : min.toString()) !== null && _min$toString !== void 0 ? _min$toString : `${MIN_INT$2}`,
+            max: (_max$toString = max === null || max === void 0 ? void 0 : max.toString()) !== null && _max$toString !== void 0 ? _max$toString : `${MAX_INT$2}`
+          },
+          defaultValue: typeof defaultValue === 'bigint' ? defaultValue.toString() : defaultValue
+        };
+      }
+    });
+  };
+}
+
+function getImageMetadata(bytes) {
+  for (const [type, checker] of types) {
+    if (checker.validate(bytes)) {
+      const result = checker.calculate(bytes);
+      if (result.width === undefined || result.height === undefined) {
+        return;
+      }
+      return {
+        width: result.width,
+        height: result.height,
+        extension: type
+      };
+    }
+  }
+}
+const types = [['jpg', JPG], ['png', PNG], ['webp', WEBP], ['gif', GIF]];
+async function getBytesFromStream(stream, maxBytes) {
+  let chunks = [];
+  for await (const chunk of stream) {
+    maxBytes -= chunk.length;
+    chunks.push(chunk);
+    if (maxBytes <= 0) {
+      break;
+    }
+  }
+  stream.destroy();
+  return Buffer.concat(chunks);
+}
+function teeStream(source) {
+  const passThrough1 = new PassThrough();
+  const passThrough2 = new PassThrough();
+  source.pipe(passThrough1);
+  source.pipe(passThrough2);
+  source.on('error', err => {
+    passThrough1.destroy(err);
+    passThrough2.destroy(err);
+  });
+  return [passThrough1, passThrough2];
+}
+
+// TODO: dynamic
+const ImageExtensionEnum = g.enum({
+  name: 'ImageExtension',
+  values: g.enumValues(SUPPORTED_IMAGE_EXTENSIONS)
+});
+const ImageFieldInput = g.inputObject({
+  name: 'ImageFieldInput',
+  fields: {
+    upload: g.arg({
+      type: g.nonNull(g.Upload)
+    })
+  }
+});
+const inputArg = g.arg({
+  type: ImageFieldInput
+});
+const ImageFieldOutput = g.object()({
+  name: 'ImageFieldOutput',
+  fields: {
+    id: g.field({
+      type: g.nonNull(g.ID)
+    }),
+    url: g.field({
+      type: g.nonNull(g.String)
+    }),
+    extension: g.field({
+      type: g.nonNull(ImageExtensionEnum)
+    }),
+    filesize: g.field({
+      type: g.nonNull(g.Int)
+    }),
+    width: g.field({
+      type: g.nonNull(g.Int)
+    }),
+    height: g.field({
+      type: g.nonNull(g.Int)
+    })
+  }
+});
+
+// this is a conservative estimate of the number of bytes
+// that we need to determine the image metadata
+// since 1Kib in memory will be fine
+const bytesToDetermineImageMetadata = 1024;
+async function inputResolver(storage, transformName, context, data) {
+  if (data === null || data === undefined) {
+    return {
+      id: data,
+      extension: data,
+      filesize: data,
+      width: data,
+      height: data
+    };
+  }
+  const upload = await data.upload;
+  let filesize = 0;
+  const _readable = upload.createReadStream();
+  const [readableForFilesize, _readable2] = teeStream(_readable);
+  const [readableForMetadata, readableForUpload] = teeStream(_readable2);
+  readableForFilesize.on('data', data => {
+    filesize += data.length;
+  });
+  const buffer = await getBytesFromStream(readableForMetadata, bytesToDetermineImageMetadata);
+  const metadata = getImageMetadata(buffer);
+  if (!metadata) {
+    throw new Error('File type not found');
+  }
+  const id = await transformName(upload.filename, metadata.extension);
+  await storage.put(`${id}.${metadata.extension}`, readableForUpload, {
+    contentType: {
+      png: 'image/png',
+      webp: 'image/webp',
+      gif: 'image/gif',
+      jpg: 'image/jpeg'
+    }[metadata.extension]
+  }, context);
+  return {
+    filesize,
+    id,
+    extension: metadata.extension,
+    height: metadata.height,
+    width: metadata.width
+  };
+}
+const extensionsSet = new Set(SUPPORTED_IMAGE_EXTENSIONS);
+function isValidImageExtension(extension) {
+  return extensionsSet.has(extension);
+}
+function image(config) {
+  const {
+    transformName = defaultTransformName
+  } = config;
+  return meta => {
+    var _config$db, _config$hooks;
+    const {
+      fieldKey
+    } = meta;
+    if ('isIndexed' in config) {
+      throw Error("isIndexed: 'unique' is not a supported option for field type image");
+    }
+    const afterOperationResolver = async function afterOperationResolver(args) {
+      if (args.operation === 'update' || args.operation === 'delete') {
+        var _args$originalItem, _args$item, _args$originalItem2, _args$item2;
+        const idKey = `${fieldKey}_id`;
+        const oldId = (_args$originalItem = args.originalItem) === null || _args$originalItem === void 0 ? void 0 : _args$originalItem[idKey];
+        const newId = (_args$item = args.item) === null || _args$item === void 0 ? void 0 : _args$item[idKey];
+        const extensionKey = `${fieldKey}_extension`;
+        const oldExtension = (_args$originalItem2 = args.originalItem) === null || _args$originalItem2 === void 0 ? void 0 : _args$originalItem2[extensionKey];
+        const newExtension = (_args$item2 = args.item) === null || _args$item2 === void 0 ? void 0 : _args$item2[extensionKey];
+        // this will occur on an update where an image already existed but has been
+        // changed, or on a delete, where there is no longer an item
+        if (typeof oldId === 'string' && typeof oldExtension === 'string' && isValidImageExtension(oldExtension) && (oldId !== newId || oldExtension !== newExtension)) {
+          await config.storage.delete(`${oldId}.${oldExtension}`, args.context);
+        }
+      }
+    };
+    return fieldType({
+      kind: 'multi',
+      extendPrismaSchema: (_config$db = config.db) === null || _config$db === void 0 ? void 0 : _config$db.extendPrismaSchema,
+      fields: {
+        id: {
+          kind: 'scalar',
+          scalar: 'String',
+          mode: 'optional'
+        },
+        extension: {
+          kind: 'scalar',
+          scalar: 'String',
+          mode: 'optional'
+        },
+        filesize: {
+          kind: 'scalar',
+          scalar: 'Int',
+          mode: 'optional'
+        },
+        width: {
+          kind: 'scalar',
+          scalar: 'Int',
+          mode: 'optional'
+        },
+        height: {
+          kind: 'scalar',
+          scalar: 'Int',
+          mode: 'optional'
+        }
+      }
+    })({
+      ...config,
+      hooks: {
+        ...config.hooks,
+        afterOperation: merge((_config$hooks = config.hooks) === null || _config$hooks === void 0 ? void 0 : _config$hooks.afterOperation, {
+          update: afterOperationResolver,
+          delete: afterOperationResolver
+        })
+      },
+      input: {
+        create: {
+          arg: inputArg,
+          resolve: (data, context) => inputResolver(config.storage, transformName, context, data)
+        },
+        update: {
+          arg: inputArg,
+          resolve: (data, context) => inputResolver(config.storage, transformName, context, data)
+        }
+      },
+      output: g.field({
+        type: ImageFieldOutput,
+        resolve({
+          value: {
+            id,
+            extension,
+            filesize,
+            width,
+            height
+          }
+        }) {
+          if (id === null) return null;
+          if (extension === null) return null;
+          if (filesize === null) return null;
+          if (width === null) return null;
+          if (height === null) return null;
+          if (!isValidImageExtension(extension)) return null; // TODO: dynamic
+
+          return {
+            id,
+            filesize,
+            width,
+            height,
+            extension,
+            url: async (_, context) => config.storage.url(`${id}.${extension}`, context)
+          };
+        }
+      }),
+      __ksTelemetryFieldTypeName: '@nixxie-cms/image',
+      views: '@nixxie-cms/core/fields/types/image/views'
+    });
+  };
+}
+function defaultTransformName(_) {
+  return randomBytes(16).toString('base64url');
+}
+
+function json({
+  defaultValue = null,
+  ...config
+} = {}) {
+  return meta => {
+    var _config$db, _config$db2;
+    if (config.isIndexed === 'unique') {
+      throw Error("isIndexed: 'unique' is not a supported option for field type json");
+    }
+    return fieldType({
+      kind: 'scalar',
+      mode: 'optional',
+      scalar: 'Json',
+      default: defaultValue === null ? undefined : meta.provider === 'sqlite' ? undefined : {
+        kind: 'literal',
+        // TODO: waiting on https://github.com/prisma/prisma/issues/26571
+        //   input.create manages defaultValues anyway
+        value: JSON.stringify(defaultValue !== null && defaultValue !== void 0 ? defaultValue : null)
+      },
+      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,
+      __ksTelemetryFieldTypeName: '@nixxie-cms/json',
+      input: {
+        create: {
+          arg: g.arg({
+            type: g.JSON
+          }),
+          resolve(val) {
+            // TODO: redundant when https://github.com/prisma/prisma/issues/26571 is resolved
+            return val === undefined ? defaultValue : val;
+          }
+        },
+        update: {
+          arg: g.arg({
+            type: g.JSON
+          })
+        }
+      },
+      output: g.field({
+        type: g.JSON
+      }),
+      views: '@nixxie-cms/core/fields/types/json/views',
+      getAdminMeta: () => ({
+        defaultValue
+      })
+    });
+  };
+}
+
+// these are the lowest and highest values for a signed 32-bit integer
+const MAX_INT$1 = 2147483647;
+const MIN_INT$1 = -2147483648;
+function select(config) {
+  const {
+    isIndexed,
+    ui: {
+      displayMode = 'select',
+      ...ui
+    } = {},
+    defaultValue,
+    validation
+  } = config;
+  return meta => {
+    var _validation$isRequire, _config$db, _config$db2;
+    const options = config.options.map(option => {
+      if (typeof option === 'string') {
+        return {
+          label: humanize(option),
+          value: option
+        };
+      }
+      return option;
+    });
+    const accepted = new Set(options.map(x => x.value));
+    if (accepted.size !== options.length) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey}: duplicate options, this is not allowed`);
+    }
+    const {
+      mode,
+      validate
+    } = makeValidateHook(meta, config, ({
+      resolvedData,
+      operation,
+      addValidationError
+    }) => {
+      if (operation === 'delete') return;
+      const value = resolvedData[meta.fieldKey];
+      if (value != null && !accepted.has(value)) {
+        addValidationError(`value is not an accepted option`);
+      }
+    });
+    const commonConfig = {
+      ...config,
+      mode,
+      ...defaultIsRequired({
+        ui
+      }, (_validation$isRequire = validation === null || validation === void 0 ? void 0 : validation.isRequired) !== null && _validation$isRequire !== void 0 ? _validation$isRequire : false),
+      hooks: {
+        ...config.hooks,
+        validate
+      },
+      __ksTelemetryFieldTypeName: '@nixxie-cms/select',
+      views: '@nixxie-cms/core/fields/types/select/views',
+      getAdminMeta: () => {
+        var _config$type;
+        return {
+          options,
+          type: (_config$type = config.type) !== null && _config$type !== void 0 ? _config$type : 'string',
+          displayMode: displayMode,
+          defaultValue: defaultValue !== null && defaultValue !== void 0 ? defaultValue : null
+        };
+      }
+    };
+    const commonDbFieldConfig = {
+      mode,
+      index: isIndexed === true ? 'index' : isIndexed || undefined,
+      default: defaultValue === undefined ? undefined : {
+        kind: 'literal',
+        value: defaultValue
+      },
+      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
+    };
+    const resolveCreate = val => {
+      if (val === undefined) {
+        var _ref;
+        return (_ref = defaultValue) !== null && _ref !== void 0 ? _ref : null;
+      }
+      return val;
+    };
+    if (config.type === 'integer') {
+      if (config.options.some(({
+        value
+      }) => !Number.isInteger(value) || value > MAX_INT$1 || value < MIN_INT$1)) {
+        throw new Error(`${meta.listKey}.${meta.fieldKey} specifies integer values that are outside the range of a 32-bit signed integer`);
+      }
+      return fieldType({
+        kind: 'scalar',
+        scalar: 'Int',
+        ...commonDbFieldConfig
+      })({
+        ...commonConfig,
+        input: {
+          uniqueWhere: isIndexed === 'unique' ? {
+            arg: g.arg({
+              type: g.Int
+            })
+          } : undefined,
+          where: {
+            arg: g.arg({
+              type: filters[meta.provider].Int[mode]
+            }),
+            resolve: mode === 'required' ? undefined : resolveCommon
+          },
+          create: {
+            arg: g.arg({
+              type: g.Int,
+              defaultValue: typeof defaultValue === 'number' ? defaultValue : undefined
+            }),
+            resolve: resolveCreate
+          },
+          update: {
+            arg: g.arg({
+              type: g.Int
+            })
+          },
+          orderBy: {
+            arg: g.arg({
+              type: orderDirectionEnum
+            })
+          }
+        },
+        output: g.field({
+          type: g.Int
+        })
+      });
+    }
+    if (config.type === 'enum') {
+      const enumName = `${meta.listKey}${humanize(meta.fieldKey).replace(/ /g, '')}Type`;
+      const enumValues = options.map(x => `${x.value}`);
+      const graphQLType = g.enum({
+        name: enumName,
+        values: g.enumValues(enumValues)
+      });
+      return fieldType(meta.provider === 'sqlite' ? {
+        kind: 'scalar',
+        scalar: 'String',
+        ...commonDbFieldConfig
+      } : {
+        kind: 'enum',
+        values: enumValues,
+        name: enumName,
+        ...commonDbFieldConfig
+      })({
+        ...commonConfig,
+        input: {
+          uniqueWhere: isIndexed === 'unique' ? {
+            arg: g.arg({
+              type: graphQLType
+            })
+          } : undefined,
+          where: {
+            arg: g.arg({
+              type: filters[meta.provider].enum(graphQLType).optional
+            }),
+            resolve: mode === 'required' ? undefined : resolveCommon
+          },
+          create: {
+            arg: g.arg({
+              type: graphQLType,
+              defaultValue: typeof defaultValue === 'string' ? defaultValue : undefined
+            }),
+            resolve: resolveCreate
+          },
+          update: {
+            arg: g.arg({
+              type: graphQLType
+            })
+          },
+          orderBy: {
+            arg: g.arg({
+              type: orderDirectionEnum
+            })
+          }
+        },
+        output: g.field({
+          type: graphQLType
+        })
+      });
+    }
+    return fieldType({
+      kind: 'scalar',
+      scalar: 'String',
+      ...commonDbFieldConfig
+    })({
+      ...commonConfig,
+      input: {
+        uniqueWhere: isIndexed === 'unique' ? {
+          arg: g.arg({
+            type: g.String
+          })
+        } : undefined,
+        where: {
+          arg: g.arg({
+            type: filters[meta.provider].String[mode]
+          }),
+          resolve: mode === 'required' ? undefined : resolveString
+        },
+        create: {
+          arg: g.arg({
+            type: g.String,
+            defaultValue: typeof defaultValue === 'string' ? defaultValue : undefined
+          }),
+          resolve: resolveCreate
+        },
+        update: {
+          arg: g.arg({
+            type: g.String
+          })
+        },
+        orderBy: {
+          arg: g.arg({
+            type: orderDirectionEnum
+          })
+        }
+      },
+      output: g.field({
+        type: g.String
+      })
+    });
+  };
+}
+
+function text(config = {}) {
+  var _config$db, _config$db2, _config$db2$isNullabl, _validation$isRequire, _validation$length$mi, _validation$length, _validation$length2, _validation$length3;
+  const {
+    defaultValue: defaultValue_,
+    isIndexed,
+    validation = {}
+  } = config;
+  (_config$db = config.db) !== null && _config$db !== void 0 ? _config$db : config.db = {};
+  (_config$db2$isNullabl = (_config$db2 = config.db).isNullable) !== null && _config$db2$isNullabl !== void 0 ? _config$db2$isNullabl : _config$db2.isNullable = false; // TODO: sigh, remove in breaking change?
+
+  const isRequired = (_validation$isRequire = validation.isRequired) !== null && _validation$isRequire !== void 0 ? _validation$isRequire : false;
+  const match = validation.match;
+  const min = validation.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 : 1 : (_validation$length2 = validation.length) === null || _validation$length2 === void 0 ? void 0 : _validation$length2.min;
+  const max = (_validation$length3 = validation.length) === null || _validation$length3 === void 0 ? void 0 : _validation$length3.max;
+  return meta => {
+    var _config$db$isNullable, _config$db3, _config$db4, _config$db5, _config$db6;
+    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`);
+    }
+
+    // defaulted to false as a zero length string is preferred to null
+    const isNullable = (_config$db$isNullable = (_config$db3 = config.db) === null || _config$db3 === void 0 ? void 0 : _config$db3.isNullable) !== null && _config$db$isNullable !== void 0 ? _config$db$isNullable : false;
+    const defaultValue = isNullable ? defaultValue_ !== null && defaultValue_ !== void 0 ? defaultValue_ : null : defaultValue_ !== null && defaultValue_ !== void 0 ? defaultValue_ : '';
+    const hasAdditionalValidation = match || min !== undefined || max !== undefined;
+    const {
+      mode,
+      validate
+    } = makeValidateHook(meta, config, hasAdditionalValidation ? ({
+      resolvedData,
+      operation,
+      addValidationError
+    }) => {
+      if (operation === 'delete') return;
+      const value = resolvedData[meta.fieldKey];
+      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}`);
+        }
+      }
+    } : undefined);
+    return fieldType({
+      kind: 'scalar',
+      mode,
+      scalar: 'String',
+      default: defaultValue === null ? undefined : {
+        kind: 'literal',
+        value: defaultValue
+      },
+      index: isIndexed === true ? 'index' : isIndexed || undefined,
+      map: (_config$db4 = config.db) === null || _config$db4 === void 0 ? void 0 : _config$db4.map,
+      nativeType: (_config$db5 = config.db) === null || _config$db5 === void 0 ? void 0 : _config$db5.nativeType,
+      extendPrismaSchema: (_config$db6 = config.db) === null || _config$db6 === void 0 ? void 0 : _config$db6.extendPrismaSchema
+    })({
+      ...config,
+      ...defaultIsRequired(config, isRequired),
+      hooks: {
+        ...config.hooks,
+        validate
+      },
+      input: {
+        uniqueWhere: isIndexed === 'unique' ? {
+          arg: g.arg({
+            type: g.String
+          })
+        } : undefined,
+        where: {
+          arg: g.arg({
+            type: filters[meta.provider].String[mode]
+          }),
+          resolve: mode === 'required' ? undefined : resolveString
+        },
+        create: {
+          arg: g.arg({
+            type: g.String,
+            defaultValue: typeof defaultValue === 'string' ? defaultValue : undefined
+          }),
+          resolve(val) {
+            if (val !== undefined) return val;
+            return defaultValue !== null && defaultValue !== void 0 ? defaultValue : null;
+          }
+        },
+        update: {
+          arg: g.arg({
+            type: g.String
+          })
+        },
+        orderBy: {
+          arg: g.arg({
+            type: orderDirectionEnum
+          })
+        }
+      },
+      output: g.field({
+        type: g.String
+      }),
+      __ksTelemetryFieldTypeName: '@nixxie-cms/text',
+      views: '@nixxie-cms/core/fields/types/text/views',
+      getAdminMeta() {
+        var _config$ui$displayMod, _config$ui, _match$explanation2;
+        return {
+          displayMode: (_config$ui$displayMod = (_config$ui = config.ui) === null || _config$ui === void 0 ? void 0 : _config$ui.displayMode) !== null && _config$ui$displayMod !== void 0 ? _config$ui$displayMod : 'input',
+          shouldUseModeInsensitive: meta.provider === 'postgresql',
+          validation: {
+            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 : null
+            }
+          },
+          defaultValue: defaultValue !== null && defaultValue !== void 0 ? defaultValue : isNullable ? null : '',
+          isNullable
+        };
+      }
+    });
+  };
+}
+
+function virtual({
+  field,
+  ...config
+}) {
+  return meta => {
+    var _config$ui, _config$ui2, _config$ui3;
+    const usableField = typeof field === 'function' ? field(meta.lists) : field;
+    const namedType = getNamedType(usableField.type);
+    const hasRequiredArgs = usableField.args && Object.values(usableField.args).some(x => x.type instanceof GNonNull && x.defaultValue === undefined);
+    if ((!isLeafType(namedType) || hasRequiredArgs) && !((_config$ui = config.ui) !== null && _config$ui !== void 0 && _config$ui.query) && (((_config$ui2 = config.ui) === null || _config$ui2 === void 0 || (_config$ui2 = _config$ui2.itemView) === null || _config$ui2 === void 0 ? void 0 : _config$ui2.fieldMode) !== 'hidden' || ((_config$ui3 = config.ui) === null || _config$ui3 === void 0 || (_config$ui3 = _config$ui3.listView) === null || _config$ui3 === void 0 ? void 0 : _config$ui3.fieldMode) !== 'hidden')) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} requires ui.query, or ui.listView.fieldMode and ui.itemView.fieldMode to be set to 'hidden'`);
+    }
+    return fieldType({
+      kind: 'none'
+    })({
+      ...config,
+      output: g.field({
+        ...usableField,
+        resolve({
+          item
+        }, ...args) {
+          return usableField.resolve(item, ...args);
+        }
+      }),
+      __ksTelemetryFieldTypeName: '@nixxie-cms/virtual',
+      views: '@nixxie-cms/core/fields/types/virtual/views',
+      getAdminMeta: () => {
+        var _config$ui$query, _config$ui4;
+        return {
+          query: (_config$ui$query = (_config$ui4 = config.ui) === null || _config$ui4 === void 0 ? void 0 : _config$ui4.query) !== null && _config$ui$query !== void 0 ? _config$ui$query : ''
+        };
+      }
+    });
+  };
+}
+
+function calendarDay(config = {}) {
+  const {
+    isIndexed,
+    validation,
+    defaultValue
+  } = config;
+  return meta => {
+    var _config$db, _config$db2, _validation$isRequire;
+    if (typeof defaultValue === 'string') {
+      try {
+        g.CalendarDay.parseValue(defaultValue);
+      } catch (err) {
+        throw new Error(`The calendarDay field at ${meta.listKey}.${meta.fieldKey} specifies defaultValue: ${defaultValue} but values must be provided as a full-date ISO8601 string such as 1970-01-01`);
+      }
+    }
+    const usesNativeDateType = meta.provider === 'postgresql' || meta.provider === 'mysql';
+    function resolveInput(value) {
+      if (meta.provider === 'sqlite' || value == null) {
+        return value;
+      }
+      return dateStringToDateObjectInUTC(value);
+    }
+    const {
+      mode,
+      validate
+    } = makeValidateHook(meta, config);
+    const commonResolveFilter = mode === 'optional' ? resolveCommon : x => x;
+    return fieldType({
+      kind: 'scalar',
+      mode,
+      scalar: usesNativeDateType ? 'DateTime' : 'String',
+      index: isIndexed === true ? 'index' : isIndexed || undefined,
+      default: typeof defaultValue === 'string' ? {
+        kind: 'literal',
+        value: defaultValue
+      } : undefined,
+      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,
+      nativeType: usesNativeDateType ? 'Date' : undefined
+    })({
+      ...config,
+      ...defaultIsRequired(config, (_validation$isRequire = validation === null || validation === void 0 ? void 0 : validation.isRequired) !== null && _validation$isRequire !== void 0 ? _validation$isRequire : false),
+      hooks: {
+        ...config.hooks,
+        validate
+      },
+      input: {
+        uniqueWhere: isIndexed === 'unique' ? {
+          arg: g.arg({
+            type: g.CalendarDay
+          }),
+          resolve: usesNativeDateType ? dateStringToDateObjectInUTC : undefined
+        } : undefined,
+        where: {
+          arg: g.arg({
+            type: mode === 'optional' ? CalendarDayNullableFilter : CalendarDayFilter
+          }),
+          resolve: usesNativeDateType ? value => commonResolveFilter(transformFilterDateStringsToDateObjects(value)) : commonResolveFilter
+        },
+        create: {
+          arg: g.arg({
+            type: g.CalendarDay,
+            defaultValue
+          }),
+          resolve(val) {
+            if (val === undefined) {
+              val = defaultValue !== null && defaultValue !== void 0 ? defaultValue : null;
+            }
+            return resolveInput(val);
+          }
+        },
+        update: {
+          arg: g.arg({
+            type: g.CalendarDay
+          }),
+          resolve: resolveInput
+        },
+        orderBy: {
+          arg: g.arg({
+            type: orderDirectionEnum
+          })
+        }
+      },
+      output: g.field({
+        type: g.CalendarDay,
+        resolve({
+          value
+        }) {
+          if (value instanceof Date) {
+            return value.toISOString().slice(0, 10);
+          }
+          return value;
+        }
+      }),
+      __ksTelemetryFieldTypeName: '@nixxie-cms/calendarDay',
+      views: '@nixxie-cms/core/fields/types/calendarDay/views',
+      getAdminMeta() {
+        return {
+          defaultValue: defaultValue !== null && defaultValue !== void 0 ? defaultValue : null
+        };
+      }
+    });
+  };
+}
+function dateStringToDateObjectInUTC(value) {
+  return new Date(`${value}T00:00Z`);
+}
+function transformFilterDateStringsToDateObjects(filter) {
+  if (filter === null) {
+    return filter;
+  }
+  return Object.fromEntries(Object.entries(filter).map(([key, value]) => {
+    if (value == null) {
+      return [key, value];
+    }
+    if (Array.isArray(value)) {
+      return [key, value.map(dateStringToDateObjectInUTC)];
+    }
+    if (typeof value === 'object') {
+      return [key, transformFilterDateStringsToDateObjects(value)];
+    }
+    return [key, dateStringToDateObjectInUTC(value)];
+  }));
+}
+const filterFields = nestedType => ({
+  equals: g.arg({
+    type: g.CalendarDay
+  }),
+  in: g.arg({
+    type: g.list(g.nonNull(g.CalendarDay))
+  }),
+  notIn: g.arg({
+    type: g.list(g.nonNull(g.CalendarDay))
+  }),
+  lt: g.arg({
+    type: g.CalendarDay
+  }),
+  lte: g.arg({
+    type: g.CalendarDay
+  }),
+  gt: g.arg({
+    type: g.CalendarDay
+  }),
+  gte: g.arg({
+    type: g.CalendarDay
+  }),
+  not: g.arg({
+    type: nestedType
+  })
+});
+const CalendarDayNullableFilter = g.inputObject({
+  name: 'CalendarDayNullableFilter',
+  fields: () => filterFields(CalendarDayNullableFilter)
+});
+const CalendarDayFilter = g.inputObject({
+  name: 'CalendarDayFilter',
+  fields: () => filterFields(CalendarDayFilter)
+});
+
+// these are the lowest and highest values for a signed 32-bit integer
+const MAX_INT = 2147483647;
+const MIN_INT = -2147483648;
+function multiselect(config) {
+  var _config$db, _config$db2, _config$db2$isNullabl;
+  const {
+    defaultValue: defaultValue_,
+    ui: {
+      displayMode = 'select',
+      ...ui
+    } = {}
+  } = config;
+  (_config$db = config.db) !== null && _config$db !== void 0 ? _config$db : config.db = {};
+  (_config$db2$isNullabl = (_config$db2 = config.db).isNullable) !== null && _config$db2$isNullabl !== void 0 ? _config$db2$isNullabl : _config$db2.isNullable = false; // TODO: deprecated, remove in breaking change
+  const defaultValue = config.db.isNullable ? defaultValue_ : defaultValue_ !== null && defaultValue_ !== void 0 ? defaultValue_ : []; // TODO: deprecated, remove in breaking change?
+
+  return meta => {
+    var _config$db3, _config$db4;
+    if (config.isIndexed === 'unique') {
+      throw TypeError("isIndexed: 'unique' is not a supported option for field type multiselect");
+    }
+    const resolveCreate = val => {
+      const resolved = resolveUpdate(val);
+      if (resolved === undefined) {
+        return defaultValue;
+      }
+      return resolved;
+    };
+    const resolveUpdate = val => {
+      return val;
+    };
+    const transformedConfig = configToOptionsAndGraphQLType(config, meta);
+    const type = g.list(g.nonNull(transformedConfig.graphqlType));
+    const accepted = new Set(transformedConfig.options.map(x => x.value));
+    if (accepted.size !== transformedConfig.options.length) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} has duplicate options, this is not allowed`);
+    }
+    const {
+      mode,
+      validate
+    } = makeValidateHook(meta, config, ({
+      inputData,
+      operation,
+      addValidationError
+    }) => {
+      if (operation === 'delete') return;
+      const values = inputData[meta.fieldKey]; // resolvedData is JSON
+      if (values != null) {
+        for (const value of values) {
+          if (!accepted.has(value)) {
+            addValidationError(`'${value}' is not an accepted option`);
+          }
+        }
+        if (new Set(values).size !== values.length) {
+          addValidationError(`non-unique set of options selected`);
+        }
+      }
+    });
+    return fieldType({
+      kind: 'scalar',
+      scalar: 'Json',
+      mode,
+      map: config === null || config === void 0 || (_config$db3 = config.db) === null || _config$db3 === void 0 ? void 0 : _config$db3.map,
+      extendPrismaSchema: (_config$db4 = config.db) === null || _config$db4 === void 0 ? void 0 : _config$db4.extendPrismaSchema,
+      default: meta.provider === 'sqlite' ? undefined : {
+        kind: 'literal',
+        // TODO: waiting on https://github.com/prisma/prisma/issues/26571
+        //   input.create manages defaultValues anyway
+        value: JSON.stringify(defaultValue !== null && defaultValue !== void 0 ? defaultValue : null)
+      }
+    })({
+      ...config,
+      ui,
+      __ksTelemetryFieldTypeName: '@nixxie-cms/multiselect',
+      hooks: {
+        ...config.hooks,
+        validate
+      },
+      views: '@nixxie-cms/core/fields/types/multiselect/views',
+      getAdminMeta: () => {
+        var _config$type;
+        return {
+          options: transformedConfig.options,
+          type: (_config$type = config.type) !== null && _config$type !== void 0 ? _config$type : 'string',
+          displayMode: displayMode,
+          defaultValue: []
+        };
+      },
+      input: {
+        create: {
+          arg: g.arg({
+            type
+          }),
+          resolve: resolveCreate
+        },
+        update: {
+          arg: g.arg({
+            type
+          }),
+          resolve: resolveUpdate
+        }
+      },
+      output: g.field({
+        type: type,
+        resolve({
+          value
+        }) {
+          return value;
+        }
+      })
+    });
+  };
+}
+function configToOptionsAndGraphQLType(config, meta) {
+  if (config.type === 'integer') {
+    if (config.options.some(({
+      value
+    }) => !Number.isInteger(value) || value > MAX_INT || value < MIN_INT)) {
+      throw new Error(`${meta.listKey}.${meta.fieldKey} specifies integer values that are outside the range of a 32-bit signed integer`);
+    }
+    return {
+      graphqlType: g.Int,
+      options: config.options
+    };
+  }
+  const options = config.options.map(option => {
+    if (typeof option === 'string') {
+      return {
+        label: humanize(option),
+        value: option
+      };
+    }
+    return option;
+  });
+  if (config.type === 'enum') {
+    const enumName = `${meta.listKey}${humanize(meta.fieldKey).replace(/ /g, '')}Type`;
+    const graphqlType = g.enum({
+      name: enumName,
+      values: g.enumValues(options.map(x => x.value))
+    });
+    return {
+      graphqlType,
+      options
+    };
+  }
+  return {
+    graphqlType: g.String,
+    options
+  };
+}
+
+export { bigInt, calendarDay, checkbox, decimal, file, float, image, integer, json, multiselect, select, text, virtual };