@nixxie-cms/core 1.0.3 → 1.1.0

package/src/lib/core/queries/output-field.ts

@@ -1,178 +1,178 @@
-import { type CacheHint, maybeCacheControlFromInfo } from '@apollo/cache-control-types'
-import DataLoader from 'dataloader'
-import type { GraphQLResolveInfo } from 'graphql'
-
-import { g } from '../../..'
-import type {
-  BaseItem,
-  BaseListTypeInfo,
-  FieldAccessControlFunction,
-  FieldReadItemAccessArgs,
-  FindManyArgsValue,
-  NixxieContext,
-  NextFieldType,
-} from '../../../types'
-import { getAccessFilters, getOperationAccess, getOperationFieldAccess } from '../access-control'
-import type { InitialisedList } from '../initialise-lists'
-import type { ResolvedDBField, ResolvedRelationDBField } from '../resolve-relationships'
-import { type IdType, getDBFieldKeyForFieldOnMultiField, weakMemoize } from '../utils'
-import * as queries from './resolvers'
-import { accessControlledFilter } from './resolvers'
-
-function getRelationVal(
-  dbField: ResolvedRelationDBField,
-  id: IdType,
-  foreignList: InitialisedList,
-  context: NixxieContext,
-  info: GraphQLResolveInfo,
-  fk: IdType | null | undefined
-) {
-  const oppositeDbField = foreignList.resolvedDbFields[dbField.field]
-  if (oppositeDbField.kind !== 'relation') throw new Error('failed assert')
-
-  if (dbField.mode === 'many') {
-    const relationFilter = {
-      [dbField.field]: oppositeDbField.mode === 'many' ? { some: { id } } : { id },
-    }
-    return {
-      findMany: async (args: FindManyArgsValue) =>
-        queries.findMany(args, foreignList, context, info, relationFilter),
-      count: async ({ where }: { where: Record<string, unknown> }) =>
-        queries.count({ where }, foreignList, context, info, relationFilter),
-    }
-  } else {
-    return async () => {
-      if (fk === null) {
-        // If the foreign key is explicitly null, there's no need to anything else,
-        // since we know the related item doesn't exist.
-        return null
-      }
-      // for one-to-many relationships, the one side always owns the foreign key
-      // so that means we have the id for the related item and we're fetching it by _its_ id.
-      // for the a one-to-one relationship though, the id might be on the related item
-      // so we need to fetch the related item by the id of the current item on the foreign key field
-      const currentItemOwnsForeignKey = fk !== undefined
-      return fetchRelatedItem(context)(foreignList)(
-        currentItemOwnsForeignKey ? 'id' : `${dbField.field}Id`
-      )(currentItemOwnsForeignKey ? fk : id)
-    }
-  }
-}
-
-function memoize<Arg, Return>(cb: (arg: Arg) => Return) {
-  const cache = new Map<Arg, Return>()
-  return (arg: Arg) => {
-    if (!cache.has(arg)) {
-      const result = cb(arg)
-      cache.set(arg, result)
-    }
-    return cache.get(arg)!
-  }
-}
-
-const fetchRelatedItem = weakMemoize((context: NixxieContext) =>
-  weakMemoize((foreignList: InitialisedList) =>
-    memoize((idFieldKey: string) => {
-      const relatedItemLoader = new DataLoader(
-        (keys: readonly IdType[]) => fetchRelatedItems(context, foreignList, idFieldKey, keys),
-        { cache: false }
-      )
-      return (id: IdType) => relatedItemLoader.load(id)
-    })
-  )
-)
-
-async function fetchRelatedItems(
-  context: NixxieContext,
-  foreignList: InitialisedList,
-  idFieldKey: string,
-  toFetch: readonly IdType[]
-) {
-  const operationAccess = await getOperationAccess(foreignList, context, 'query')
-  if (!operationAccess) {
-    return toFetch.map(() => undefined)
-  }
-
-  const accessFilters = await getAccessFilters(foreignList, context, 'query')
-  if (accessFilters === false) {
-    return toFetch.map(() => undefined)
-  }
-
-  const toFetchUnique = Array.from(new Set(toFetch))
-  const resolvedWhere = await accessControlledFilter(
-    foreignList,
-    context,
-    { [idFieldKey]: { in: toFetchUnique } },
-    accessFilters
-  )
-
-  const results = await context.prisma[foreignList.listKey].findMany({ where: resolvedWhere })
-  const resultsById = new Map(results.map((x: any) => [x[idFieldKey], x]))
-  return toFetch.map(id => resultsById.get(id))
-}
-
-function getValueForDBField(
-  item: BaseItem,
-  dbField: ResolvedDBField,
-  id: IdType,
-  fieldPath: string,
-  context: NixxieContext,
-  lists: Record<string, InitialisedList>,
-  info: GraphQLResolveInfo
-) {
-  if (dbField.kind === 'multi') {
-    return Object.fromEntries(
-      Object.keys(dbField.fields).map(innerDBFieldKey => {
-        const keyOnDbValue = getDBFieldKeyForFieldOnMultiField(fieldPath, innerDBFieldKey)
-        return [innerDBFieldKey, item[keyOnDbValue] as any]
-      })
-    )
-  }
-  if (dbField.kind === 'relation') {
-    // If we're holding a foreign key value, let's take advantage of that.
-    let fk: IdType | undefined
-    if (dbField.mode === 'one' && dbField.foreignIdField.kind !== 'none') {
-      fk = item[`${fieldPath}Id`] as IdType
-    }
-    return getRelationVal(dbField, id, lists[dbField.list], context, info, fk)
-  } else {
-    return item[fieldPath] as any
-  }
-}
-
-export function outputTypeField(
-  output: NextFieldType['output'],
-  dbField: ResolvedDBField,
-  cacheHint: CacheHint | undefined,
-  access: FieldAccessControlFunction<FieldReadItemAccessArgs<BaseListTypeInfo>>,
-  listKey: string,
-  fieldKey: string,
-  lists: Record<string, InitialisedList>
-) {
-  const list = lists[listKey]
-
-  return g.field({
-    type: output.type,
-    deprecationReason: output.deprecationReason,
-    description: output.description,
-    args: output.args,
-    extensions: output.extensions,
-    async resolve(item: BaseItem, args, context, info) {
-      const id = item.id as IdType
-      const fieldAccess = await getOperationFieldAccess(item, list, fieldKey, context, 'read')
-      if (!fieldAccess) return null
-
-      // only static cache hints are supported at the field level until a use-case makes it clear what parameters a dynamic hint would take
-      if (cacheHint && info) {
-        maybeCacheControlFromInfo(info)?.setCacheHint(cacheHint)
-      }
-
-      const value = getValueForDBField(item, dbField, id, fieldKey, context, lists, info)
-      if (output.resolve) {
-        return output.resolve({ value, item: item }, args, context, info)
-      } else {
-        return value
-      }
-    },
-  })
-}
+import { type CacheHint, maybeCacheControlFromInfo } from '@apollo/cache-control-types'
+import DataLoader from 'dataloader'
+import type { GraphQLResolveInfo } from 'graphql'
+
+import { g } from '../../..'
+import type {
+  BaseItem,
+  BaseCollectionTypeInfo,
+  FieldAccessControlFunction,
+  FieldReadItemAccessArgs,
+  FindManyArgsValue,
+  NixxieContext,
+  NextFieldType,
+} from '../../../types'
+import { getAccessFilters, getOperationAccess, getOperationFieldAccess } from '../access-control'
+import type { InitialisedList } from '../initialise-lists'
+import type { ResolvedDBField, ResolvedRelationDBField } from '../resolve-relationships'
+import { type IdType, getDBFieldKeyForFieldOnMultiField, weakMemoize } from '../utils'
+import * as queries from './resolvers'
+import { accessControlledFilter } from './resolvers'
+
+function getRelationVal(
+  dbField: ResolvedRelationDBField,
+  id: IdType,
+  foreignList: InitialisedList,
+  context: NixxieContext,
+  info: GraphQLResolveInfo,
+  fk: IdType | null | undefined
+) {
+  const oppositeDbField = foreignList.resolvedDbFields[dbField.field]
+  if (oppositeDbField.kind !== 'relation') throw new Error('failed assert')
+
+  if (dbField.mode === 'many') {
+    const relationFilter = {
+      [dbField.field]: oppositeDbField.mode === 'many' ? { some: { id } } : { id },
+    }
+    return {
+      findMany: async (args: FindManyArgsValue) =>
+        queries.findMany(args, foreignList, context, info, relationFilter),
+      count: async ({ where }: { where: Record<string, unknown> }) =>
+        queries.count({ where }, foreignList, context, info, relationFilter),
+    }
+  } else {
+    return async () => {
+      if (fk === null) {
+        // If the foreign key is explicitly null, there's no need to anything else,
+        // since we know the related item doesn't exist.
+        return null
+      }
+      // for one-to-many relationships, the one side always owns the foreign key
+      // so that means we have the id for the related item and we're fetching it by _its_ id.
+      // for the a one-to-one relationship though, the id might be on the related item
+      // so we need to fetch the related item by the id of the current item on the foreign key field
+      const currentItemOwnsForeignKey = fk !== undefined
+      return fetchRelatedItem(context)(foreignList)(
+        currentItemOwnsForeignKey ? 'id' : `${dbField.field}Id`
+      )(currentItemOwnsForeignKey ? fk : id)
+    }
+  }
+}
+
+function memoize<Arg, Return>(cb: (arg: Arg) => Return) {
+  const cache = new Map<Arg, Return>()
+  return (arg: Arg) => {
+    if (!cache.has(arg)) {
+      const result = cb(arg)
+      cache.set(arg, result)
+    }
+    return cache.get(arg)!
+  }
+}
+
+const fetchRelatedItem = weakMemoize((context: NixxieContext) =>
+  weakMemoize((foreignList: InitialisedList) =>
+    memoize((idFieldKey: string) => {
+      const relatedItemLoader = new DataLoader(
+        (keys: readonly IdType[]) => fetchRelatedItems(context, foreignList, idFieldKey, keys),
+        { cache: false }
+      )
+      return (id: IdType) => relatedItemLoader.load(id)
+    })
+  )
+)
+
+async function fetchRelatedItems(
+  context: NixxieContext,
+  foreignList: InitialisedList,
+  idFieldKey: string,
+  toFetch: readonly IdType[]
+) {
+  const operationAccess = await getOperationAccess(foreignList, context, 'query')
+  if (!operationAccess) {
+    return toFetch.map(() => undefined)
+  }
+
+  const accessFilters = await getAccessFilters(foreignList, context, 'query')
+  if (accessFilters === false) {
+    return toFetch.map(() => undefined)
+  }
+
+  const toFetchUnique = Array.from(new Set(toFetch))
+  const resolvedWhere = await accessControlledFilter(
+    foreignList,
+    context,
+    { [idFieldKey]: { in: toFetchUnique } },
+    accessFilters
+  )
+
+  const results = await context.prisma[foreignList.listKey].findMany({ where: resolvedWhere })
+  const resultsById = new Map(results.map((x: any) => [x[idFieldKey], x]))
+  return toFetch.map(id => resultsById.get(id))
+}
+
+function getValueForDBField(
+  item: BaseItem,
+  dbField: ResolvedDBField,
+  id: IdType,
+  fieldPath: string,
+  context: NixxieContext,
+  lists: Record<string, InitialisedList>,
+  info: GraphQLResolveInfo
+) {
+  if (dbField.kind === 'multi') {
+    return Object.fromEntries(
+      Object.keys(dbField.fields).map(innerDBFieldKey => {
+        const keyOnDbValue = getDBFieldKeyForFieldOnMultiField(fieldPath, innerDBFieldKey)
+        return [innerDBFieldKey, item[keyOnDbValue] as any]
+      })
+    )
+  }
+  if (dbField.kind === 'relation') {
+    // If we're holding a foreign key value, let's take advantage of that.
+    let fk: IdType | undefined
+    if (dbField.mode === 'one' && dbField.foreignIdField.kind !== 'none') {
+      fk = item[`${fieldPath}Id`] as IdType
+    }
+    return getRelationVal(dbField, id, lists[dbField.list], context, info, fk)
+  } else {
+    return item[fieldPath] as any
+  }
+}
+
+export function outputTypeField(
+  output: NextFieldType['output'],
+  dbField: ResolvedDBField,
+  cacheHint: CacheHint | undefined,
+  access: FieldAccessControlFunction<FieldReadItemAccessArgs<BaseCollectionTypeInfo>>,
+  listKey: string,
+  fieldKey: string,
+  lists: Record<string, InitialisedList>
+) {
+  const list = lists[listKey]
+
+  return g.field({
+    type: output.type,
+    deprecationReason: output.deprecationReason,
+    description: output.description,
+    args: output.args,
+    extensions: output.extensions,
+    async resolve(item: BaseItem, args, context, info) {
+      const id = item.id as IdType
+      const fieldAccess = await getOperationFieldAccess(item, list, fieldKey, context, 'read')
+      if (!fieldAccess) return null
+
+      // only static cache hints are supported at the field level until a use-case makes it clear what parameters a dynamic hint would take
+      if (cacheHint && info) {
+        maybeCacheControlFromInfo(info)?.setCacheHint(cacheHint)
+      }
+
+      const value = getValueForDBField(item, dbField, id, fieldKey, context, lists, info)
+      if (output.resolve) {
+        return output.resolve({ value, item: item }, args, context, info)
+      } else {
+        return value
+      }
+    },
+  })
+}

package/src/lib/env.ts

@@ -0,0 +1,50 @@
+import type { NixxieEnvSpec, NixxieEnvVarSpec } from '../types'
+
+function normalise(spec: NixxieEnvSpec): Record<string, NixxieEnvVarSpec> {
+  if (Array.isArray(spec)) {
+    return Object.fromEntries((spec as readonly string[]).map(name => [name, {}]))
+  }
+  return spec as Record<string, NixxieEnvVarSpec>
+}
+
+/**
+ * Validate `env` (default `process.env`) against a spec. Applies `default`s to the env
+ * object for unset variables, then throws one aggregated error listing every missing or
+ * malformed variable. Called automatically when the config declares `env`, and exported
+ * for standalone use.
+ */
+export function validateEnv(
+  spec: NixxieEnvSpec,
+  env: Record<string, string | undefined> = process.env
+): void {
+  const problems: string[] = []
+
+  for (const [name, requirement] of Object.entries(normalise(spec))) {
+    let value = env[name]
+
+    if ((value === undefined || value === '') && requirement.default !== undefined) {
+      env[name] = requirement.default
+      value = requirement.default
+    }
+
+    const describe = requirement.description ? ` — ${requirement.description}` : ''
+
+    if (value === undefined || value === '') {
+      if (requirement.required !== false) {
+        problems.push(`  • ${name} is not set${describe}`)
+      }
+      continue
+    }
+
+    if (requirement.pattern && !requirement.pattern.test(value)) {
+      problems.push(`  • ${name} does not match ${requirement.pattern}${describe}`)
+    }
+  }
+
+  if (problems.length) {
+    throw new Error(
+      `Environment validation failed (${problems.length} problem${problems.length === 1 ? '' : 's'}):\n` +
+        problems.join('\n')
+    )
+  }
+}

package/src/lib/id-field.ts

@@ -1,7 +1,7 @@
 import type { GArg, GInputObjectType, InferValueFromArg } from '../graphql-ts'
 import type { ScalarDBField } from '../types'
 import {
-  type BaseListTypeInfo,
+  type BaseCollectionTypeInfo,
   type DatabaseProvider,
   type FieldTypeFunc,
   type IdFieldConfig,
@@ -140,7 +140,7 @@ function unpack(
   throw new Error(`Unknown id type ${kind}`)
 }
 
-export function idFieldType(config: IdFieldConfig): FieldTypeFunc<BaseListTypeInfo> {
+export function idFieldType(config: IdFieldConfig): FieldTypeFunc<BaseCollectionTypeInfo> {
   const kind = config.kind
   const dbFieldOptions = unpack(config)
   const parseTypeFn = {