@nixxie-cms/core 1.0.0

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

@@ -0,0 +1,182 @@
+import type { SimpleFieldTypeInfo } from '../../../types'
+import {
+  type BaseListTypeInfo,
+  type CommonFieldConfig,
+  type FieldTypeFunc,
+  fieldType,
+  orderDirectionEnum,
+  Decimal,
+} from '../../../types'
+import { g } from '../../..'
+import { filters } from '../../filters'
+import { makeValidateHook, defaultIsRequired } from '../../non-null-graphql'
+import type { controller } from './views'
+
+export type DecimalFieldConfig<ListTypeInfo extends BaseListTypeInfo> = CommonFieldConfig<
+  ListTypeInfo,
+  SimpleFieldTypeInfo<'Decimal'>
+> & {
+  isIndexed?: boolean | 'unique'
+  defaultValue?: string | null
+  validation?: {
+    isRequired?: boolean
+    min?: string
+    max?: string
+  }
+  precision?: number
+  scale?: number
+  db?: {
+    isNullable?: boolean
+    map?: string
+    extendPrismaSchema?: (field: string) => string
+  }
+}
+
+function safeParseDecimal(value: string | null | undefined) {
+  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
+export function decimal<ListTypeInfo extends BaseListTypeInfo>(
+  config: DecimalFieldConfig<ListTypeInfo> = {}
+): FieldTypeFunc<ListTypeInfo> {
+  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(max) ?? undefined
+  const parsedMin = safeParseDecimal(min) ?? undefined
+
+  return meta => {
+    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?.map,
+      extendPrismaSchema: config.db?.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' ? filters.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: Decimal & { scaleToPrint?: number } = new Decimal(value)
+          val.scaleToPrint = scale
+          return val
+        },
+      }),
+      __ksTelemetryFieldTypeName: '@nixxie-cms/decimal',
+      views: '@nixxie-cms/core/fields/types/decimal/views',
+      getAdminMeta(): Parameters<typeof controller>[0]['fieldMeta'] {
+        return {
+          validation: {
+            max: max ?? null,
+            min: min ?? null,
+          },
+          defaultValue,
+        }
+      },
+    })
+  }
+}

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

@@ -0,0 +1,215 @@
+import { useState } from 'react'
+
+import { TextField } from '@keystar/ui/text-field'
+
+import {
+  type FieldController,
+  type FieldControllerConfig,
+  type FieldProps,
+  type SimpleFieldTypeInfo,
+  Decimal,
+} 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 | null
+  max: string | null
+}
+
+function validate_(
+  value: Value,
+  validation: Validation,
+  isRequired: boolean,
+  label: string
+): string | undefined {
+  const { value: input, kind } = value
+  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 = new Decimal(input)
+    if (!v.isFinite()) return `${label} is not finite`
+    if (validation.min && v.lessThan(new Decimal(validation.min)))
+      return `${label} must be greater than or equal to ${validation.min}`
+    if (validation.max && v.greaterThan(new Decimal(validation.max)))
+      return `${label} must be less than or equal to ${validation.max}`
+  } catch (e: any) {
+    return e?.message ?? 'error'
+  }
+}
+
+export function controller(
+  config: FieldControllerConfig<{
+    validation: Validation
+    defaultValue: string | null
+  }>
+): FieldController<Value, string | null, SimpleFieldTypeInfo<'Decimal'>['inputs']['where']> & {
+  validation: Validation
+} {
+  const validate = (value: Value, opts: { isRequired: boolean }) => {
+    return validate_(value, config.fieldMeta.validation, opts.isRequired, config.label)
+  }
+
+  return {
+    fieldKey: config.fieldKey,
+    label: config.label,
+    description: config.description,
+    defaultValue: { kind: 'create', value: config.fieldMeta.defaultValue },
+    deserialize: data => ({
+      kind: 'update',
+      value: data[config.fieldKey],
+      initial: data[config.fieldKey],
+    }),
+    serialize: value => ({ [config.fieldKey]: value.value }),
+    validation: config.fieldMeta.validation,
+    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="decimal"
+            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,
+        },
+      },
+    },
+
+    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
+
+  const validate = (value: Value) => {
+    return validate_(value, field.validation, isRequired, field.label)
+  }
+
+  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/file/index.ts

@@ -0,0 +1,168 @@
+import type {
+  BaseNixxieTypeInfo,
+  BaseListTypeInfo,
+  CommonFieldConfig,
+  FieldHooks,
+  FieldTypeFunc,
+  NixxieContext,
+  MaybePromise,
+  StorageStrategy,
+} from '../../../types'
+import { fieldType } from '../../../types'
+import { g } from '../../..'
+import { merge } from '../../resolve-hooks'
+import type { InferValueFromArg, InferValueFromInputType } from '@graphql-ts/schema'
+import { randomBytes } from 'node:crypto'
+
+export type FieldTypeInfo = {
+  item: undefined
+  inputs: {
+    create: InferValueFromInputType<typeof FileFieldInput> | null | undefined
+    update: InferValueFromInputType<typeof FileFieldInput> | null | undefined
+    where: undefined
+    uniqueWhere: undefined
+    orderBy: undefined
+  }
+  prisma: {
+    create: undefined
+    update: undefined
+  }
+}
+
+export type FileFieldConfig<ListTypeInfo extends BaseListTypeInfo> = CommonFieldConfig<
+  ListTypeInfo,
+  FieldTypeInfo
+> & {
+  storage: StorageStrategy<ListTypeInfo['all']>
+  transformName?: (originalFilename: string) => MaybePromise<string>
+  db?: {
+    extendPrismaSchema?: (field: string) => string
+  }
+}
+
+const FileFieldInput = g.inputObject({
+  name: 'FileFieldInput',
+  fields: {
+    upload: g.arg({ type: g.nonNull(g.Upload) }),
+  },
+})
+
+const inputArg = g.arg({ type: FileFieldInput })
+
+const FileFieldOutput = g.object<{
+  filename: string
+  filesize: number
+  url: (_args: {}, context: NixxieContext) => Promise<string>
+}>()({
+  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(
+  storage: StorageStrategy<BaseNixxieTypeInfo>,
+  transformName: (originalFilename: string) => Promise<string> | string,
+  context: NixxieContext,
+  data: InferValueFromArg<typeof inputArg>
+) {
+  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 }
+}
+
+export function file<ListTypeInfo extends BaseListTypeInfo>(
+  config: FileFieldConfig<ListTypeInfo>
+): FieldTypeFunc<ListTypeInfo> {
+  const { transformName = defaultTransformName } = config
+  return meta => {
+    const { fieldKey } = meta
+
+    if ('isIndexed' in config) {
+      throw Error("isIndexed: 'unique' is not a supported option for field type file")
+    }
+
+    const afterOperationResolver: Extract<
+      FieldHooks<BaseListTypeInfo, FieldTypeInfo>['afterOperation'],
+      (args: any) => any
+    > = async function afterOperationResolver(args) {
+      if (args.operation === 'update' || args.operation === 'delete') {
+        const filenameKey = `${fieldKey}_filename`
+        const oldFilename = args.originalItem[filenameKey] as string | null | undefined
+        const newFilename = args.item?.[filenameKey] as string | null | undefined
+
+        // 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?.extendPrismaSchema,
+      fields: {
+        filesize: { kind: 'scalar', scalar: 'Int', mode: 'optional' },
+        filename: { kind: 'scalar', scalar: 'String', mode: 'optional' },
+      },
+    })({
+      ...config,
+      hooks: {
+        ...config.hooks,
+        afterOperation: merge(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: 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(path: string) {
+  // 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})?$/) as RegExpMatchArray
+
+  const id = randomBytes(16).toString('base64url')
+  const urlSafeName = name.replace(/[^A-Za-z0-9]/g, '-')
+  if (ext) return `${urlSafeName}-${id}${ext}`
+  return `${urlSafeName}-${id}`
+}