@nixxie-cms/core 1.0.0

package/src/fields/types/bigInt/index.ts

@@ -0,0 +1,181 @@
+import type { SimpleFieldTypeInfo } from '../../../types'
+import {
+  type BaseListTypeInfo,
+  type CommonFieldConfig,
+  type FieldTypeFunc,
+  fieldType,
+  orderDirectionEnum,
+} from '../../../types'
+import { g } from '../../..'
+import { filters } from '../../filters'
+import { resolveDbNullable, makeValidateHook, defaultIsRequired } from '../../non-null-graphql'
+import type { controller } from './views'
+
+export type BigIntFieldConfig<ListTypeInfo extends BaseListTypeInfo> = CommonFieldConfig<
+  ListTypeInfo,
+  SimpleFieldTypeInfo<'BigInt'>
+> & {
+  isIndexed?: boolean | 'unique'
+  defaultValue?: bigint | null | { kind: 'autoincrement' }
+  validation?: {
+    isRequired?: boolean
+    min?: bigint
+    max?: bigint
+  }
+  db?: {
+    isNullable?: boolean
+    map?: string
+    extendPrismaSchema?: (field: string) => string
+  }
+}
+
+// for a signed 64-bit integer
+const MAX_INT = 9223372036854775807n
+const MIN_INT = -9223372036854775808n
+
+// TODO: https://github.com/Nixxie/keystatic/blob/main/design-system/pkg/src/number-field/NumberField.tsx
+export function bigInt<ListTypeInfo extends BaseListTypeInfo>(
+  config: BigIntFieldConfig<ListTypeInfo> = {}
+): FieldTypeFunc<ListTypeInfo> {
+  const { defaultValue: defaultValue_ = null, isIndexed, validation = {} } = config
+
+  const { isRequired = false, min, max } = validation
+  const defaultValue =
+    typeof defaultValue_ === 'bigint' ? defaultValue_ : (defaultValue_?.kind ?? null)
+
+  return meta => {
+    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 || min < MIN_INT)) {
+      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 || max < MIN_INT)) {
+      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?.map,
+      extendPrismaSchema: config.db?.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' ? filters.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(): Parameters<typeof controller>[0]['fieldMeta'] {
+        return {
+          validation: {
+            min: min?.toString() ?? `${MIN_INT}`,
+            max: max?.toString() ?? `${MAX_INT}`,
+          },
+          defaultValue: typeof defaultValue === 'bigint' ? defaultValue.toString() : defaultValue,
+        }
+      },
+    })
+  }
+}

package/src/fields/types/bigInt/views/index.tsx

@@ -0,0 +1,254 @@
+import { useState } from 'react'
+
+import { ContextualHelp } from '@keystar/ui/contextual-help'
+import { Content } from '@keystar/ui/slots'
+import { TextField } from '@keystar/ui/text-field'
+import { Heading, Text } from '@keystar/ui/typography'
+
+import type { SimpleFieldTypeInfo } from '../../../../types'
+import type { FieldController, FieldControllerConfig, FieldProps } from '../../../../types'
+import { entriesTyped } from '../../../../lib/core/utils'
+
+const TYPE_OPERATOR_MAP = {
+  equals: '=',
+  not: '≠',
+  gt: '>',
+  lt: '<',
+  gte: '≥',
+  lte: '≤',
+} as const
+
+type Value =
+  | { kind: 'create'; value: string | null }
+  | { kind: 'update'; initial: string | null; value: string | null }
+
+type Validation = {
+  min: string
+  max: string
+}
+
+function validate_(
+  value: Value,
+  validation: Validation,
+  isRequired: boolean,
+  label: string,
+  hasAutoIncrementDefault: boolean
+): string | undefined {
+  const { value: input, kind } = value
+  if (kind === 'create' && hasAutoIncrementDefault && input === null) return
+  if (kind === 'update' && value.initial === null && input === null) return
+  if (isRequired && input === null) return `${label} is required`
+  if (typeof input !== 'string') return
+  try {
+    const v = BigInt(input)
+    if (validation.min !== undefined && v < BigInt(validation.min))
+      return `${label} must be greater than or equal to ${validation.min}`
+    if (validation.max !== undefined && v > BigInt(validation.max))
+      return `${label} must be less than or equal to ${validation.max}`
+  } catch (e: any) {
+    return `${label} is not a valid BigInt`
+  }
+}
+
+export function controller(
+  config: FieldControllerConfig<{
+    validation: Validation
+    defaultValue: string | null | 'autoincrement'
+  }>
+): FieldController<Value, string | null, SimpleFieldTypeInfo<'BigInt'>['inputs']['where']> & {
+  validation: Validation
+  hasAutoIncrementDefault: boolean
+} {
+  const validate = (value: Value, opts: { isRequired: boolean }) => {
+    return validate_(
+      value,
+      config.fieldMeta.validation,
+      opts.isRequired,
+      config.label,
+      config.fieldMeta.defaultValue === 'autoincrement'
+    )
+  }
+
+  return {
+    fieldKey: config.fieldKey,
+    label: config.label,
+    description: config.description,
+    validation: config.fieldMeta.validation,
+    defaultValue: {
+      kind: 'create',
+      value:
+        config.fieldMeta.defaultValue === 'autoincrement' ? null : config.fieldMeta.defaultValue,
+    },
+    deserialize: data => ({
+      kind: 'update',
+      value: data[config.fieldKey],
+      initial: data[config.fieldKey],
+    }),
+    serialize: value => ({ [config.fieldKey]: value.value }),
+    graphqlSelection: config.fieldKey,
+    filter: {
+      Filter(props) {
+        const {
+          autoFocus,
+          context,
+          forceValidation,
+          typeLabel,
+          onChange,
+          type,
+          value,
+          ...otherProps
+        } = props
+        const [isDirty, setDirty] = useState(false)
+        if (type === 'empty' || type === 'not_empty') return null
+
+        const labelProps =
+          context === 'add' ? { label: config.label, description: typeLabel } : { label: typeLabel }
+
+        return (
+          <TextField
+            {...otherProps}
+            {...labelProps}
+            autoFocus={autoFocus}
+            errorMessage={
+              (forceValidation || isDirty) &&
+              !validate({ kind: 'update', initial: null, value }, { isRequired: true })
+                ? 'Required'
+                : null
+            }
+            inputMode="numeric"
+            width="auto"
+            onBlur={() => setDirty(true)}
+            onChange={x => onChange?.(x === '' ? null : x)}
+            value={value ?? ''}
+          />
+        )
+      },
+
+      graphql: ({ type, value }) => {
+        if (type === 'empty') return { [config.fieldKey]: { equals: null } }
+        if (type === 'not_empty') return { [config.fieldKey]: { not: { equals: null } } }
+        if (type === 'not') return { [config.fieldKey]: { not: { equals: value } } }
+        return { [config.fieldKey]: { [type]: value } }
+      },
+      parseGraphQL: value => {
+        return entriesTyped(value).flatMap(([type, value]) => {
+          if (type === 'equals' && value === null) {
+            return [{ type: 'empty', value: null }]
+          }
+          if (!value) return []
+          if (type === 'equals') return { type: 'equals', value: value as unknown as string }
+          if (type === 'not') {
+            if (value?.equals === null) return { type: 'not_empty', value: null }
+            return { type: 'not', value: value.equals as unknown as string }
+          }
+          if (type === 'gt' || type === 'gte' || type === 'lt' || type === 'lte') {
+            return { type, value: value as unknown as string }
+          }
+          return []
+        })
+      },
+      Label({ label, type, value }) {
+        if (type === 'empty' || type === 'not_empty') return label.toLocaleLowerCase()
+        const operator = TYPE_OPERATOR_MAP[type as keyof typeof TYPE_OPERATOR_MAP]
+        return `${operator} ${value}`
+      },
+      types: {
+        equals: {
+          label: 'Is exactly',
+          initialValue: null,
+        },
+        not: {
+          label: 'Is not exactly',
+          initialValue: null,
+        },
+        gt: {
+          label: 'Is greater than',
+          initialValue: null,
+        },
+        lt: {
+          label: 'Is less than',
+          initialValue: null,
+        },
+        gte: {
+          label: 'Is greater than or equal to',
+          initialValue: null,
+        },
+        lte: {
+          label: 'Is less than or equal to',
+          initialValue: null,
+        },
+        empty: {
+          label: 'Is empty',
+          initialValue: null,
+        },
+        not_empty: {
+          label: 'Is not empty',
+          initialValue: null,
+        },
+      },
+    },
+
+    hasAutoIncrementDefault: config.fieldMeta.defaultValue === 'autoincrement',
+    validate: (value, opts) => validate(value, opts) === undefined,
+  }
+}
+
+export function Field({
+  field,
+  value,
+  onChange,
+  autoFocus,
+  forceValidation,
+  isRequired,
+}: FieldProps<typeof controller>) {
+  const [isDirty, setDirty] = useState(false)
+  const isReadOnly = !onChange || field.hasAutoIncrementDefault
+
+  if (field.hasAutoIncrementDefault && value.kind === 'create') {
+    return (
+      <TextField
+        autoFocus={autoFocus}
+        description={field.description}
+        label={field.label}
+        isReadOnly
+        defaultValue="--"
+        contextualHelp={
+          <ContextualHelp>
+            <Heading>Auto increment</Heading>
+            <Content>
+              <Text>
+                This field is set to auto increment. It will default to the next available number.
+              </Text>
+            </Content>
+          </ContextualHelp>
+        }
+      />
+    )
+  }
+
+  const validate = (value: Value) => {
+    return validate_(
+      value,
+      field.validation,
+      isRequired,
+      field.label,
+      field.hasAutoIncrementDefault
+    )
+  }
+
+  return (
+    <TextField
+      autoFocus={autoFocus}
+      description={field.description}
+      label={field.label}
+      errorMessage={(forceValidation || isDirty) && validate(value)}
+      isReadOnly={isReadOnly}
+      isRequired={isRequired}
+      inputMode="numeric"
+      width="alias.singleLineWidth"
+      onBlur={() => setDirty(true)}
+      onChange={x => onChange?.({ ...value, value: x === '' ? null : x })}
+      value={value.value ?? ''}
+    />
+  )
+}

package/src/fields/types/bytes/index.ts

@@ -0,0 +1,275 @@
+import {
+  type BaseListTypeInfo,
+  type CommonFieldConfig,
+  type FieldTypeFunc,
+  fieldType,
+  orderDirectionEnum,
+} from '../../../types'
+import { g } from '../../..'
+import { makeValidateHook, defaultIsRequired } from '../../non-null-graphql'
+import { weakMemoize } from '../../../lib/core/utils'
+import { GraphQLError } from 'graphql'
+import type {
+  GArg,
+  GInputObjectType,
+  GList,
+  GNonNull,
+  GScalarType,
+  InferValueFromInputType,
+} from '@graphql-ts/schema'
+
+export type FieldTypeInfo = {
+  item: Uint8Array | null
+  inputs: {
+    create: Uint8Array | null | undefined
+    update: Uint8Array | null | undefined
+    where: InferValueFromInputType<BytesFilterType> | undefined
+    uniqueWhere: Uint8Array | null | undefined
+    orderBy: undefined
+  }
+  prisma: {
+    create: Uint8Array | null | undefined
+    update: Uint8Array | null | undefined
+  }
+}
+
+export type BytesFieldConfig<ListTypeInfo extends BaseListTypeInfo> = CommonFieldConfig<
+  ListTypeInfo,
+  FieldTypeInfo
+> & {
+  isIndexed?: boolean | 'unique'
+  graphql?: {
+    scalar?: GScalarType<Uint8Array, string>
+  }
+  validation?: {
+    /**
+     * Makes the field disallow null values. It does not constrain the length of the value.
+     */
+    isRequired?: boolean
+    /**
+     * Specifies the minimum and maximum length of the value in _bytes_. It does _not_ represent the length in the encoded form.
+     */
+    length?: { min?: number; max?: number }
+  }
+  defaultValue?: Uint8Array | null
+  db?: {
+    isNullable?: boolean
+    map?: string
+    extendPrismaSchema?: (field: string) => string
+    /**
+     * The underlying database type.
+     * Only some of the types are supported on PostgreSQL and MySQL.
+     * The native type is not customisable on SQLite.
+     * See Prisma's documentation for more information about the supported types.
+     *
+     * https://www.prisma.io/docs/orm/reference/prisma-schema-reference#bytes
+     */
+    nativeType?: string
+  }
+}
+
+export type TextFieldMeta = {
+  isNullable: boolean
+  defaultValue: string | null
+}
+
+export function bytes<ListTypeInfo extends BaseListTypeInfo>(
+  config: BytesFieldConfig<ListTypeInfo> = {}
+): FieldTypeFunc<ListTypeInfo> {
+  const { defaultValue = null, isIndexed, validation = {} } = config
+
+  const scalar = config.graphql?.scalar ?? g.Hex
+
+  config.db ??= {}
+
+  const isRequired = validation.isRequired ?? false
+  const min = validation.isRequired ? (validation.length?.min ?? 1) : validation.length?.min
+  const max = validation.length?.max
+
+  return meta => {
+    {
+      const serializedExample = scalar.serialize(new Uint8Array([0]))
+      if (typeof serializedExample !== 'string') {
+        throw new Error(
+          `The GraphQL scalar type specified for ${meta.listKey}.${meta.fieldKey} must serialize Uint8Arrays to strings`
+        )
+      }
+    }
+    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 (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`
+      )
+    }
+
+    const hasAdditionalValidation = min !== undefined || max !== undefined
+    const { mode, validate } = makeValidateHook(
+      meta,
+      config,
+      hasAdditionalValidation
+        ? ({ resolvedData, operation, addValidationError }) => {
+            if (operation === 'delete') return
+
+            const value: Uint8Array | null | undefined = 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} bytes long`)
+                }
+              }
+              if (max !== undefined && value.length > max) {
+                addValidationError(`value must be no longer than ${max} bytes`)
+              }
+            }
+          }
+        : undefined
+    )
+
+    let clientSideDefaultValue = null
+    if (defaultValue !== null) {
+      clientSideDefaultValue = scalar.serialize(defaultValue)
+      if (typeof clientSideDefaultValue !== 'string') {
+        throw new Error(
+          `The GraphQL scalar type specified for ${meta.listKey}.${meta.fieldKey} must serialize Uint8Arrays to strings`
+        )
+      }
+    } else if (mode === 'required') {
+      clientSideDefaultValue = scalar.serialize(new Uint8Array(0))
+      if (typeof clientSideDefaultValue !== 'string') {
+        throw new Error(
+          `The GraphQL scalar type specified for ${meta.listKey}.${meta.fieldKey} must serialize Uint8Arrays to strings`
+        )
+      }
+    }
+
+    return fieldType({
+      kind: 'scalar',
+      mode,
+      scalar: 'Bytes',
+      default: defaultValue === null ? undefined : { kind: 'literal', value: defaultValue },
+      index: isIndexed === true ? 'index' : isIndexed || undefined,
+      map: config.db?.map,
+      nativeType: config.db?.nativeType,
+      extendPrismaSchema: config.db?.extendPrismaSchema,
+    })({
+      ...config,
+      ...defaultIsRequired(config, isRequired),
+      hooks: {
+        ...config.hooks,
+        validate,
+      },
+      input: {
+        uniqueWhere: isIndexed === 'unique' ? { arg: g.arg({ type: scalar }) } : undefined,
+        where: {
+          arg: g.arg({
+            type: mode === 'optional' ? getNullableFilterType(scalar) : getFilterType(scalar),
+          }),
+        },
+        create: {
+          arg: g.arg({
+            type: scalar,
+          }),
+          resolve(val) {
+            if (val !== undefined) return val
+            return defaultValue ?? null
+          },
+        },
+        update: { arg: g.arg({ type: scalar }) },
+        orderBy: { arg: g.arg({ type: orderDirectionEnum }) },
+      },
+      output: g.field({ type: scalar }),
+      __ksTelemetryFieldTypeName: '@nixxie-cms/bytes',
+      views: '@nixxie-cms/core/fields/types/bytes/views',
+      getAdminMeta(): TextFieldMeta {
+        return {
+          defaultValue: clientSideDefaultValue,
+          isNullable: mode === 'optional',
+        }
+      },
+    })
+  }
+}
+
+type BytesFilterType = GInputObjectType<{
+  equals?: GArg<GScalarType<Uint8Array, string>>
+  in?: GArg<GList<GNonNull<GScalarType<Uint8Array, string>>>>
+  notIn?: GArg<GList<GNonNull<GScalarType<Uint8Array, string>>>>
+  not?: GArg<BytesFilterType>
+}>
+
+// the weakMemoizes are important so reusing the same scalar type for multiple `bytes` fields uses the same (===) filter type
+// rather than a duplicate one which would cause an error about two types with the same name
+const getFilterType = weakMemoize((scalar: GScalarType<Uint8Array, string>) => {
+  const filter: BytesFilterType = g.inputObject({
+    name: `${scalar.name}Filter`,
+    fields: () => ({
+      equals: g.arg({ type: scalar }),
+      in: g.arg({ type: g.list(g.nonNull(scalar)) }),
+      notIn: g.arg({ type: g.list(g.nonNull(scalar)) }),
+      not: g.arg({ type: filter }),
+    }),
+  })
+  return filter
+})
+
+const getNullableFilterType = weakMemoize((scalar: GScalarType<Uint8Array, string>) => {
+  const filter: BytesFilterType = g.inputObject({
+    name: `${scalar.name}NullableFilter`,
+    fields: () => ({
+      equals: g.arg({ type: scalar }),
+      in: g.arg({ type: g.list(g.nonNull(scalar)) }),
+      notIn: g.arg({ type: g.list(g.nonNull(scalar)) }),
+      not: g.arg({ type: filter }),
+    }),
+  })
+  return filter
+})
+
+export function bytesScalar(opts: {
+  name: string
+  serialize: (value: Uint8Array) => string
+  parse: (value: string) => Uint8Array
+  description?: string
+  specifiedByURL?: string
+}) {
+  return g.scalar<Uint8Array, string>({
+    name: opts.name,
+    description: opts.description,
+    specifiedByURL: opts.specifiedByURL,
+    parseLiteral(value) {
+      if (value.kind !== 'StringValue') {
+        throw new GraphQLError(`${opts.name} only accepts values as strings`)
+      }
+      return opts.parse(value.value)
+    },
+    parseValue(value) {
+      // so that when you're doing a mutation in a resolver, you can just pass in a Uint8Array directly
+      if (value instanceof Uint8Array) {
+        // duplicate it though to avoid any weirdness with the array being mutated
+        // + ensuring that if you pass in a Buffer, resolvers receive a normal Uint8Array
+        return Uint8Array.from(value)
+      }
+      if (typeof value !== 'string') {
+        throw new GraphQLError(`${opts.name} only accepts values as strings`)
+      }
+      return opts.parse(value)
+    },
+    serialize(value) {
+      if (!(value instanceof Uint8Array)) {
+        throw new GraphQLError(`unexpected value provided to ${opts.name} scalar: ${value}`)
+      }
+      return opts.serialize(value)
+    },
+  })
+}