@nixxie-cms/core 1.0.0

package/src/lib/core/mutations/nested-mutation-many-input-resolvers.ts

@@ -0,0 +1,145 @@
+import type { NixxieContext, GraphQLTypesForList } from '../../../types'
+import type { UniqueInputFilter } from '../where-inputs'
+import type { InitialisedList } from '../initialise-lists'
+import { isRejected, isFulfilled } from '../utils'
+import { userInputError } from '../graphql-errors'
+import type { NestedMutationState } from './'
+import { checkUniqueItemExists } from '../access-control'
+import type { InferValueFromArg, GArg } from '@graphql-ts/schema'
+
+type _CreateValueType = Exclude<
+  InferValueFromArg<GArg<Exclude<GraphQLTypesForList['relateTo']['many']['create'], undefined>>>,
+  null | undefined
+>
+
+type _UpdateValueType = Exclude<
+  InferValueFromArg<GArg<Exclude<GraphQLTypesForList['relateTo']['many']['update'], undefined>>>,
+  null | undefined
+>
+
+export class RelationshipErrors extends Error {
+  errors: { error: Error; tag: string }[]
+  constructor(errors: { error: Error; tag: string }[]) {
+    super('Multiple relationship errors')
+    this.errors = errors
+  }
+}
+
+function getResolvedUniqueWheres(
+  uniqueInputs: UniqueInputFilter[],
+  context: NixxieContext,
+  foreignList: InitialisedList,
+  operation: string
+) {
+  return uniqueInputs.map(uniqueInput =>
+    checkUniqueItemExists(uniqueInput, foreignList, context, operation)
+  )
+}
+
+export function resolveRelateToManyForCreateInput(
+  nestedMutationState: NestedMutationState,
+  context: NixxieContext,
+  foreignList: InitialisedList,
+  tag: string
+) {
+  return async (value: _CreateValueType) => {
+    if (
+      !Array.isArray(value.connect) &&
+      !Array.isArray(value.create) &&
+      !Array.isArray(value.set)
+    ) {
+      throw userInputError(
+        `You must provide at least one of "set", "connect" or "create" in to-many relationship inputs for "create" operations.`
+      )
+    }
+
+    // Perform queries for the connections
+    const connects = Promise.allSettled(
+      getResolvedUniqueWheres(value.connect ?? [], context, foreignList, 'connect')
+    )
+    const sets = Promise.allSettled(
+      getResolvedUniqueWheres(value.set ?? [], context, foreignList, 'set')
+    )
+
+    // Perform nested mutations for the creations
+    const creates = Promise.allSettled(
+      (value.create ?? []).map(x => nestedMutationState.create(x, foreignList))
+    )
+
+    // Resolve items
+    const [connectResult, createResult, setResult] = await Promise.all([connects, creates, sets])
+
+    // Collect all the errors
+    const errors = [...connectResult, ...createResult, ...setResult].filter(isRejected)
+    if (errors.length) throw new RelationshipErrors(errors.map(x => ({ error: x.reason, tag })))
+
+    return {
+      connect: [...setResult, ...connectResult, ...createResult]
+        .filter(isFulfilled)
+        .map(x => x.value),
+    }
+  }
+}
+
+export function resolveRelateToManyForUpdateInput(
+  nestedMutationState: NestedMutationState,
+  context: NixxieContext,
+  foreignList: InitialisedList,
+  tag: string
+) {
+  return async (value: _UpdateValueType) => {
+    if (
+      !Array.isArray(value.connect) &&
+      !Array.isArray(value.create) &&
+      !Array.isArray(value.disconnect) &&
+      !Array.isArray(value.set)
+    ) {
+      throw userInputError(
+        `You must provide at least one of "set", "connect", "create" or "disconnect" in to-many relationship inputs for "update" operations.`
+      )
+    }
+
+    if (value.set && value.disconnect) {
+      throw userInputError(
+        `The "set" and "disconnect" fields cannot both be provided to to-many relationship inputs for "update" operations.`
+      )
+    }
+
+    // Perform queries for the connections
+    const connects = Promise.allSettled(
+      getResolvedUniqueWheres(value.connect ?? [], context, foreignList, 'connect')
+    )
+    const disconnects = Promise.allSettled(
+      getResolvedUniqueWheres(value.disconnect ?? [], context, foreignList, 'disconnect')
+    )
+    const sets = Promise.allSettled(
+      getResolvedUniqueWheres(value.set ?? [], context, foreignList, 'set')
+    )
+
+    // Perform nested mutations for the creations
+    const creates = Promise.allSettled(
+      (value.create ?? []).map(x => nestedMutationState.create(x, foreignList))
+    )
+
+    // Resolve items
+    const [connectResult, createResult, disconnectResult, setResult] = await Promise.all([
+      connects,
+      creates,
+      disconnects,
+      sets,
+    ])
+
+    // Collect all the errors
+    const errors = [...connectResult, ...createResult, ...disconnectResult, ...setResult].filter(
+      isRejected
+    )
+    if (errors.length) throw new RelationshipErrors(errors.map(x => ({ error: x.reason, tag })))
+
+    return {
+      // unlike all the other operations, an empty array isn't a no-op for set
+      set: value.set ? setResult.filter(isFulfilled).map(x => x.value) : undefined,
+      disconnect: disconnectResult.filter(isFulfilled).map(x => x.value),
+      connect: [...connectResult, ...createResult].filter(isFulfilled).map(x => x.value),
+    }
+  }
+}

package/src/lib/core/mutations/nested-mutation-one-input-resolvers.ts

@@ -0,0 +1,71 @@
+import type { NixxieContext, GraphQLTypesForList } from '../../../types'
+import type { InitialisedList } from '../initialise-lists'
+import { userInputError } from '../graphql-errors'
+import type { NestedMutationState } from './'
+import { checkUniqueItemExists } from '../access-control'
+import type { InferValueFromArg, GArg, GNonNull } from '@graphql-ts/schema'
+
+type _CreateValueType = Exclude<
+  InferValueFromArg<GArg<Exclude<GraphQLTypesForList['relateTo']['one']['create'], undefined>>>,
+  null | undefined
+>
+type _UpdateValueType = Exclude<
+  InferValueFromArg<
+    GArg<GNonNull<Exclude<GraphQLTypesForList['relateTo']['one']['update'], undefined>>>
+  >,
+  null | undefined
+>
+
+async function handleCreateAndUpdate(
+  value: _CreateValueType,
+  nestedMutationState: NestedMutationState,
+  context: NixxieContext,
+  foreignList: InitialisedList
+) {
+  if (value.connect) {
+    return { connect: await checkUniqueItemExists(value.connect, foreignList, context, 'connect') }
+  }
+
+  if (value.create) {
+    const { id } = await nestedMutationState.create(value.create, foreignList)
+    return { connect: { id } }
+  }
+}
+
+export function resolveRelateToOneForCreateInput(
+  nestedMutationState: NestedMutationState,
+  context: NixxieContext,
+  foreignList: InitialisedList
+) {
+  return async (value: _CreateValueType) => {
+    const numOfKeys = Object.keys(value).length
+    if (numOfKeys !== 1) {
+      throw userInputError(
+        `You must provide "connect" or "create" in to-one relationship inputs for "create" operations.`
+      )
+    }
+    return handleCreateAndUpdate(value, nestedMutationState, context, foreignList)
+  }
+}
+
+export function resolveRelateToOneForUpdateInput(
+  nestedMutationState: NestedMutationState,
+  context: NixxieContext,
+  foreignList: InitialisedList
+) {
+  return async (value: _UpdateValueType) => {
+    if (Object.keys(value).length !== 1) {
+      throw userInputError(
+        `You must provide one of "connect", "create" or "disconnect" in to-one relationship inputs for "update" operations.`
+      )
+    }
+
+    if (value.connect || value.create) {
+      return handleCreateAndUpdate(value, nestedMutationState, context, foreignList)
+    }
+
+    if (value.disconnect) {
+      return { disconnect: true }
+    }
+  }
+}

package/src/lib/core/prisma-schema-printer.ts

@@ -0,0 +1,256 @@
+import type { ScalarDBField, ScalarDBFieldDefault } from '../../types'
+import type { ResolvedDBField } from './resolve-relationships'
+import type { InitialisedList } from './initialise-lists'
+import type { NixxieConfig } from '../../types'
+import { areArraysEqual, getDBFieldKeyForFieldOnMultiField } from './utils'
+
+const modifiers = {
+  required: '',
+  optional: '?',
+  many: '[]',
+}
+
+function printIndex(fieldPath: string, index: undefined | 'index' | 'unique') {
+  return {
+    none: '',
+    unique: '@unique',
+    index: `\n@@index([${fieldPath}])`,
+  }[index ?? ('none' as const)]
+}
+
+function printNativeType(nativeType: string | undefined, datasourceName: string) {
+  return nativeType === undefined ? '' : ` @${datasourceName}.${nativeType}`
+}
+
+function printScalarDefaultValue(defaultValue: ScalarDBFieldDefault): string {
+  if (defaultValue.kind === 'literal') {
+    if (defaultValue instanceof Uint8Array) {
+      // can't find documentation for it but it seems the expected format for Bytes defaults in Prisma is base64
+      // https://github.com/prisma/prisma-engines/blob/11f45a26bee8dc9c91606fc5130d1025a6e22197/psl/psl-core/src/validate/validation_pipeline/validations/default_value.rs#L77
+      return ` @default("${Buffer.from(defaultValue).toString('base64')}")`
+    }
+    if (typeof defaultValue.value === 'string') {
+      return ` @default(${JSON.stringify(defaultValue.value)})`
+    }
+    return ` @default(${defaultValue.value.toString()})`
+  }
+  if (defaultValue.kind === 'cuid' || defaultValue.kind === 'uuid') {
+    return ` @default(${defaultValue.kind}(${defaultValue.version ?? ''}))`
+  }
+  if (defaultValue.kind === 'nanoid') {
+    return ` @default(nanoid(${defaultValue.length ?? ''}))`
+  }
+  if (
+    defaultValue.kind === 'now' ||
+    defaultValue.kind === 'autoincrement' ||
+    defaultValue.kind === 'ulid'
+  ) {
+    return ` @default(${defaultValue.kind}())`
+  }
+  if (defaultValue.kind === 'dbgenerated') {
+    return ` @default(dbgenerated(${JSON.stringify(defaultValue.value)}))`
+  }
+  if (defaultValue.kind === 'random') {
+    return ''
+  }
+  assertNever(defaultValue)
+}
+
+function assertNever(arg: never): never {
+  throw new Error(`expected to never be called but was called with ${arg}`)
+}
+
+function printField(
+  fieldPath: string,
+  field: Exclude<ResolvedDBField, { kind: 'none' }>,
+  datasourceName: string,
+  lists: Record<string, InitialisedList>
+): string {
+  if (field.kind === 'scalar') {
+    const nativeType = printNativeType(field.nativeType, datasourceName)
+    const index = printIndex(fieldPath, field.index)
+
+    const defaultValue = field.default ? printScalarDefaultValue(field.default) : ''
+    const map = field.map ? ` @map(${JSON.stringify(field.map)})` : ''
+    const updatedAt = field.updatedAt ? ' @updatedAt' : ''
+    return `${fieldPath} ${field.scalar}${modifiers[field.mode]}${updatedAt}${nativeType}${defaultValue}${map}${index}`
+  }
+
+  if (field.kind === 'enum') {
+    const index = printIndex(fieldPath, field.index)
+    const defaultValue = field.default ? ` @default(${field.default.value})` : ''
+    const map = field.map ? ` @map(${JSON.stringify(field.map)})` : ''
+    return `${fieldPath} ${field.name}${modifiers[field.mode]}${defaultValue}${map}${index}`
+  }
+
+  if (field.kind === 'multi') {
+    return Object.entries(field.fields)
+      .map(([subField, field]) =>
+        printField(
+          getDBFieldKeyForFieldOnMultiField(fieldPath, subField),
+          field,
+          datasourceName,
+          lists
+        )
+      )
+      .join('\n')
+  }
+
+  if (field.kind === 'relation') {
+    if (field.mode === 'many')
+      return `${fieldPath} ${field.list}[] @relation("${field.relationName}")`
+    if (field.foreignIdField.kind === 'none')
+      return `${fieldPath} ${field.list}? @relation("${field.relationName}")`
+
+    const relationIdFieldPath = `${fieldPath}Id`
+    const relationField = `${fieldPath} ${field.list}? @relation("${field.relationName}", fields: [${relationIdFieldPath}], references: [id])`
+
+    const foreignList = lists[field.list]
+    const foreignIdField = foreignList.resolvedDbFields.id
+
+    assertDbFieldIsValidForIdField(foreignList.listKey, foreignList.isSingleton, foreignIdField)
+    const nativeType = printNativeType(foreignIdField.nativeType, datasourceName)
+
+    const foreignIndex = field.foreignIdField.kind === 'owned' ? 'index' : 'unique'
+    const index = printIndex(relationIdFieldPath, foreignIndex)
+    const relationIdField = `${relationIdFieldPath} ${foreignIdField.scalar}? @map(${JSON.stringify(field.foreignIdField.map)}) ${nativeType}${index}`
+    return `${relationField}\n${relationIdField}`
+  }
+  // TypeScript's control flow analysis doesn't understand that this will never happen without the assertNever
+  // (this will still correctly validate if any case is unhandled though)
+  return assertNever(field)
+}
+
+function collectEnums(lists: Record<string, InitialisedList>) {
+  const enums: Record<string, { values: readonly string[]; firstDefinedByRef: string }> = {}
+  for (const [listKey, { resolvedDbFields }] of Object.entries(lists)) {
+    for (const [fieldPath, field] of Object.entries(resolvedDbFields)) {
+      const fields =
+        field.kind === 'multi'
+          ? Object.entries(field.fields).map(
+              ([key, field]) => [field, `${listKey}.${fieldPath} (sub field ${key})`] as const
+            )
+          : [[field, `${listKey}.${fieldPath}`] as const]
+
+      for (const [field, ref] of fields) {
+        if (field.kind !== 'enum') continue
+        const alreadyExistingEnum = enums[field.name]
+        if (alreadyExistingEnum === undefined) {
+          enums[field.name] = {
+            values: field.values,
+            firstDefinedByRef: ref,
+          }
+          continue
+        }
+        if (!areArraysEqual(alreadyExistingEnum.values, field.values)) {
+          throw new Error(
+            `The fields ${alreadyExistingEnum.firstDefinedByRef} and ${ref} both specify Prisma schema enums` +
+              `with the name ${field.name} but they have different values:\n` +
+              `enum from ${alreadyExistingEnum.firstDefinedByRef}:\n${JSON.stringify(
+                alreadyExistingEnum.values,
+                null,
+                2
+              )}\n` +
+              `enum from ${ref}:\n${JSON.stringify(field.values, null, 2)}`
+          )
+        }
+      }
+    }
+  }
+  return Object.entries(enums)
+    .map(([enumName, { values }]) => `enum ${enumName} {\n${values.join('\n')}\n}`)
+    .join('\n')
+}
+
+function assertDbFieldIsValidForIdField(
+  listKey: string,
+  isSingleton: boolean,
+  field: ResolvedDBField
+): asserts field is ScalarDBField<'Int' | 'String', 'required'> {
+  if (field.kind !== 'scalar') {
+    throw new Error(
+      `id fields must be either a String or Int Prisma scalar but the id field for the ${listKey} list is not a scalar`
+    )
+  }
+  // this may be loosened in the future
+  if (field.scalar !== 'String' && field.scalar !== 'Int' && field.scalar !== 'BigInt') {
+    throw new Error(
+      `id fields must be String, Int or BigInt Prisma scalars but the id field for the ${listKey} list is a ${field.scalar} scalar`
+    )
+  }
+  if (field.mode !== 'required') {
+    throw new Error(
+      `id fields must be a singular required field but the id field for the ${listKey} list is ${
+        field.mode === 'many' ? 'a many' : 'an optional'
+      } field`
+    )
+  }
+  if (field.index !== undefined) {
+    throw new Error(
+      `id fields must not specify indexes themselves but the id field for the ${listKey} list specifies an index`
+    )
+  }
+}
+
+export function printPrismaSchema(config: NixxieConfig, lists: Record<string, InitialisedList>) {
+  const { prismaClientPath, provider, extendPrismaSchema: extendPrismaCompleteSchema } = config.db
+
+  const prismaSchema = [
+    `// This file is automatically generated by Nixxie, do not modify it manually.`,
+    `// Modify your Nixxie config when you want to change this.`,
+    ``,
+    `datasource ${provider} {`,
+    `  url = env("DATABASE_URL")`,
+    `  shadowDatabaseUrl = env("SHADOW_DATABASE_URL")`,
+    `  provider = "${provider}"`,
+    `}`,
+    ``,
+    `generator client {`,
+    `  provider = "prisma-client-js"`,
+    ...(prismaClientPath === '@prisma/client' ? [] : [`  output = "${prismaClientPath}"`]),
+    '}',
+  ]
+
+  for (const [
+    listKey,
+    {
+      resolvedDbFields,
+      prisma: { mapping, extendPrismaSchema: extendPrismaListSchema },
+      isSingleton,
+    },
+  ] of Object.entries(lists)) {
+    const listPrisma = [`model ${listKey} {`]
+
+    for (const [fieldPath, field] of Object.entries(resolvedDbFields)) {
+      if (fieldPath === 'id') {
+        assertDbFieldIsValidForIdField(listKey, isSingleton, field)
+      }
+
+      if (field.kind !== 'none') {
+        let fieldPrisma = printField(fieldPath, field, provider, lists)
+        if (fieldPath === 'id') {
+          fieldPrisma += ' @id'
+        }
+
+        listPrisma.push(
+          field.extendPrismaSchema ? field.extendPrismaSchema(fieldPrisma) : fieldPrisma
+        )
+      }
+    }
+
+    if (mapping !== undefined) {
+      listPrisma.push(`@@map(${JSON.stringify(mapping)})`)
+    }
+
+    listPrisma.push('}')
+    const listPrismaStr = listPrisma.join('\n')
+
+    prismaSchema.push(
+      extendPrismaListSchema ? extendPrismaListSchema(listPrismaStr) : listPrismaStr
+    )
+  }
+  prismaSchema.push(collectEnums(lists))
+
+  const prismaSchemaStr = prismaSchema.join('\n')
+  return extendPrismaCompleteSchema?.(prismaSchemaStr) ?? prismaSchemaStr
+}

package/src/lib/core/queries/index.ts

@@ -0,0 +1,66 @@
+import { g } from '../../..'
+import type { InitialisedList } from '../initialise-lists'
+import { withSpan } from '../../otel'
+import * as queries from './resolvers'
+
+export function getQueriesForList(list: InitialisedList) {
+  if (!list.graphql.isEnabled.query) return {}
+
+  const findOne = g.field({
+    type: list.graphql.types.output,
+    args: {
+      where: g.arg({
+        type: g.nonNull(list.graphql.types.uniqueWhere),
+        defaultValue: list.isSingleton ? { id: '1' } : undefined,
+      }),
+    },
+    async resolve(_, args, context, info) {
+      return await withSpan(
+        `query ${info.fieldName}`,
+        async () => {
+          return queries.findOne(args, list, context, info)
+        },
+        { 'nixxie.list': list.listKey }
+      )
+    },
+  })
+
+  const findMany = g.field({
+    type: g.list(g.nonNull(list.graphql.types.output)),
+    args: list.graphql.types.findManyArgs,
+    async resolve(_, args, context, info) {
+      return await withSpan(
+        `query ${info.fieldName}`,
+        async () => {
+          return queries.findMany(args, list, context, info)
+        },
+        { 'nixxie.list': list.listKey }
+      )
+    },
+  })
+
+  const countQuery = g.field({
+    type: g.Int,
+    args: {
+      where: g.arg({
+        type: g.nonNull(list.graphql.types.where),
+        defaultValue: list.isSingleton ? { id: { equals: '1' } } : {},
+      }),
+    },
+    async resolve(_, args, context, info) {
+      return await withSpan(
+        `query ${info.fieldName}`,
+        async () => {
+          return queries.count(args, list, context, info)
+        },
+        { 'nixxie.list': list.listKey }
+      )
+    },
+  })
+
+  return {
+    [list.graphql.names.itemQueryName]: findOne,
+    [list.graphql.names.listQueryName]: findMany,
+    [list.graphql.names.listQueryCountName]: countQuery,
+  }
+}