@nixxie-cms/core 1.0.0

package/src/lib/id-field.ts

@@ -0,0 +1,214 @@
+import type { GArg, GInputObjectType, InferValueFromArg } from '../graphql-ts'
+import type { ScalarDBField } from '../types'
+import {
+  type BaseListTypeInfo,
+  type DatabaseProvider,
+  type FieldTypeFunc,
+  type IdFieldConfig,
+  fieldType,
+  orderDirectionEnum,
+} from '../types'
+import { g } from '../types/schema'
+import { userInputError } from './core/graphql-errors'
+
+type IDType = string | number | null
+
+function isInt(x: IDType) {
+  if (x === null) return
+  if (x === '') return
+  const nom = typeof x === 'string' ? Number(x) : x
+  if (Number.isInteger(nom)) return nom
+}
+
+function isBigInt(x: IDType) {
+  if (x === null) return
+  if (x === '') return
+  try {
+    return BigInt(x)
+  } catch {}
+}
+
+function isString(x: IDType) {
+  if (typeof x !== 'string') return
+  if (x === '') return
+  return x
+}
+
+// TODO: this should be on the user, remove in breaking change?
+function isUuid(x: IDType) {
+  if (typeof x !== 'string') return
+  if (x === '') return
+  return x.toLowerCase()
+}
+
+const nonCircularFields = {
+  equals: g.arg({ type: g.ID }),
+  in: g.arg({ type: g.list(g.nonNull(g.ID)) }),
+  notIn: g.arg({ type: g.list(g.nonNull(g.ID)) }),
+  lt: g.arg({ type: g.ID }),
+  lte: g.arg({ type: g.ID }),
+  gt: g.arg({ type: g.ID }),
+  gte: g.arg({ type: g.ID }),
+}
+
+type IDFilterType = GInputObjectType<
+  typeof nonCircularFields & {
+    not: GArg<typeof IDFilter>
+  }
+>
+
+const IDFilter: IDFilterType = g.inputObject({
+  name: 'IDFilter',
+  fields: () => ({
+    ...nonCircularFields,
+    not: g.arg({ type: IDFilter }),
+  }),
+})
+
+const filterArg = g.arg({ type: IDFilter })
+
+function resolveInput(
+  input: Exclude<InferValueFromArg<typeof filterArg>, undefined>,
+  parseId: (x: IDType) => unknown
+) {
+  const where: any = {}
+  if (input === null) return where
+
+  for (const key of ['equals', 'gt', 'gte', 'lt', 'lte'] as const) {
+    const value = input[key]
+    if (value === undefined) continue
+    where[key] = parseId(value)
+  }
+
+  for (const key of ['in', 'notIn'] as const) {
+    const value = input[key]
+    if (!Array.isArray(value)) continue
+
+    where[key] = value.map(x => parseId(x))
+  }
+
+  if (input.not !== undefined) {
+    where.not = resolveInput(input.not, parseId)
+  }
+
+  return where
+}
+
+const NATIVE_TYPES: {
+  [k in DatabaseProvider]?: {
+    [ku in IdFieldConfig['kind']]?: string
+  }
+} = {
+  postgresql: {
+    uuid: 'Uuid' as const,
+  },
+}
+
+function unpack(
+  i: IdFieldConfig
+): Pick<ScalarDBField<'String' | 'Int' | 'BigInt', 'required'>, 'scalar' | 'default'> {
+  if (i.kind === 'random') {
+    const { kind, bytes, encoding } = i
+    if (typeof bytes === 'number') {
+      if (bytes !== bytes >>> 0) {
+        throw new TypeError(`Expected positive integer for random bytes, not ${bytes}`)
+      }
+    }
+
+    return {
+      scalar: 'String',
+      // our defaults are 32 bytes, as base64url
+      //   256 / Math.log2(64) ~ 43 characters
+      //
+      // for case-insensitive databases that is
+      //   225 bits ~ Math.log2((26 + 10 + 2) ** 43)
+      default: {
+        kind,
+        bytes: bytes ?? 32,
+        encoding: encoding ?? 'base64url',
+      },
+    }
+  }
+  const { kind, type } = i
+  if (kind === 'cuid') return { scalar: 'String', default: { kind, version: i.version } }
+  if (kind === 'uuid') return { scalar: 'String', default: { kind, version: i.version } }
+  if (kind === 'nanoid') return { scalar: 'String', default: { kind, length: i.length } }
+  if (kind === 'ulid') return { scalar: 'String', default: { kind } }
+  if (kind === 'string') return { scalar: 'String', default: undefined }
+  if (kind === 'number') return { scalar: type ?? 'Int', default: undefined }
+  if (kind === 'autoincrement') return { scalar: type ?? 'Int', default: { kind } }
+  throw new Error(`Unknown id type ${kind}`)
+}
+
+export function idFieldType(config: IdFieldConfig): FieldTypeFunc<BaseListTypeInfo> {
+  const kind = config.kind
+  const dbFieldOptions = unpack(config)
+  const parseTypeFn = {
+    Int: isInt,
+    BigInt: isBigInt,
+    String: isString,
+    UUID: isUuid, // TODO: remove in breaking change
+  }[kind === 'uuid' ? 'UUID' : dbFieldOptions.scalar]
+
+  function parse(value: IDType) {
+    const result = parseTypeFn(value)
+    if (result === undefined) {
+      throw userInputError(
+        `Only a ${dbFieldOptions.scalar.toLowerCase()} can be passed to id filters`
+      )
+    }
+    return result
+  }
+
+  return meta => {
+    if (
+      meta.provider === 'sqlite' &&
+      kind === 'autoincrement' &&
+      dbFieldOptions.scalar === 'BigInt'
+    ) {
+      throw new Error(
+        `{ kind: ${kind}, type: ${dbFieldOptions.scalar} } is not supported by SQLite`
+      )
+    }
+
+    return fieldType({
+      ...dbFieldOptions,
+      kind: 'scalar',
+      mode: 'required',
+      nativeType: NATIVE_TYPES[meta.provider]?.[kind],
+    })({
+      ...config,
+
+      // the ID field is always filterable and orderable
+      isFilterable: true, // TODO: should it be?
+      isOrderable: true, // TODO: should it be?
+
+      input: {
+        where: {
+          arg: filterArg,
+          resolve(val) {
+            return resolveInput(val, parse)
+          },
+        },
+        uniqueWhere: { arg: g.arg({ type: g.ID }), resolve: parse },
+        orderBy: { arg: g.arg({ type: orderDirectionEnum }) },
+      },
+      output: g.field({
+        type: g.nonNull(g.ID),
+        resolve({ value }) {
+          return value.toString()
+        },
+      }),
+      views: '@nixxie-cms/core/___internal-do-not-use-will-break-in-patch/admin-ui/id-field-view',
+      getAdminMeta: () => ({ kind, type: dbFieldOptions.scalar }),
+      ui: {
+        createView: {
+          fieldMode: 'hidden',
+        },
+        itemView: {
+          fieldPosition: 'sidebar',
+        },
+      },
+    })
+  }
+}

package/src/lib/middleware.ts

@@ -0,0 +1,68 @@
+import path from 'node:path'
+
+import type express from 'express'
+import type next from 'next'
+import { pkgDir } from '../pkg-dir'
+import type { NixxieConfig, NixxieContext } from '../types'
+
+const adminErrorHTMLFilepath = path.join(pkgDir, 'static', 'admin-error.html')
+
+export function createAdminUIMiddlewareWithNextApp(
+  config: NixxieConfig,
+  commonContext: NixxieContext,
+  nextApp: ReturnType<typeof next>
+) {
+  const handle = nextApp.getRequestHandler()
+
+  const {
+    ui: { isAccessAllowed, pageMiddleware, publicPages, basePath },
+  } = config
+
+  if (basePath.endsWith('/')) throw new TypeError('basePath must not end with a trailing slash')
+
+  return async (req: express.Request, res: express.Response) => {
+    const { path } = req
+
+    if (path.startsWith(`${basePath}/_next`) || path.startsWith(`${basePath}/__next`)) {
+      return handle(req, res)
+    }
+
+    try {
+      // do nothing if this is a public page
+      const isPublicPage = publicPages.includes(path)
+      const context = await commonContext.withRequest(req, res)
+      const wasAccessAllowed = isPublicPage ? true : await isAccessAllowed(context)
+      const shouldRedirect = await pageMiddleware?.({
+        context,
+        wasAccessAllowed,
+        basePath,
+      })
+
+      if (shouldRedirect) {
+        res.header('Cache-Control', 'no-cache, max-age=0')
+        res.header('Location', shouldRedirect.to)
+        res.status(302)
+        res.send()
+        return
+      }
+
+      if (!wasAccessAllowed) return nextApp.render(req, res, '/no-access')
+
+      handle(req, res)
+    } catch (e) {
+      console.error('An error occurred handling a request for the Admin UI:', e)
+      res.status(500)
+      res.format({
+        'text/html': function () {
+          res.sendFile(adminErrorHTMLFilepath)
+        },
+        'application/json': function () {
+          res.send({ error: true })
+        },
+        default: function () {
+          res.send('An error occurred handling a request for the Admin UI.')
+        },
+      })
+    }
+  }
+}

package/src/lib/migrations.ts

@@ -0,0 +1,90 @@
+import { join, dirname } from 'node:path'
+import { toSchemasContainer, loadSchemaContext } from '@prisma/internals'
+import { Migrate } from '@prisma/migrate'
+
+import type { System } from './system'
+
+function setOrRemoveEnvVariable(name: string, value: string | undefined) {
+  if (value === undefined) {
+    delete process.env[name]
+    return
+  }
+  process.env[name] = value
+}
+
+export async function withMigrate<T>(
+  prismaSchemaPath: string,
+  system: {
+    config: {
+      db: Pick<System['config']['db'], 'url' | 'shadowDatabaseUrl'>
+    }
+  },
+  cb: (operations: {
+    apply: () => Promise<any>
+    diagnostic: () => Promise<any>
+    push: (force: boolean) => Promise<any>
+    reset: () => Promise<any>
+    schema: (_: string, force: boolean) => Promise<any>
+  }) => Promise<T>
+) {
+  const schemaContext = await loadSchemaContext({
+    schemaPathFromArg: prismaSchemaPath,
+    printLoadMessage: false,
+    ignoreEnvVarErrors: true,
+  })
+  const migrate = await Migrate.setup({
+    schemaContext,
+    migrationsDirPath: join(dirname(prismaSchemaPath), 'migrations'),
+  })
+  async function run<T>(f: () => T) {
+    // only required once - on child process start - but easiest to do this always
+    const prevDBURLFromEnv = process.env.DATABASE_URL
+    const prevShadowDBURLFromEnv = process.env.SHADOW_DATABASE_URL
+    const prevHiddenUpdateMessage = process.env.PRISMA_HIDE_UPDATE_MESSAGE
+    try {
+      process.env.DATABASE_URL = system.config.db.url
+      setOrRemoveEnvVariable('SHADOW_DATABASE_URL', system.config.db.shadowDatabaseUrl)
+      process.env.PRISMA_HIDE_UPDATE_MESSAGE = '1' // temporarily silence
+      return await f()
+    } finally {
+      setOrRemoveEnvVariable('DATABASE_URL', prevDBURLFromEnv)
+      setOrRemoveEnvVariable('SHADOW_DATABASE_URL', prevShadowDBURLFromEnv)
+      setOrRemoveEnvVariable('PRISMA_HIDE_UPDATE_MESSAGE', prevHiddenUpdateMessage)
+    }
+  }
+
+  try {
+    return await cb({
+      async apply() {
+        return run(() => migrate.applyMigrations())
+      },
+      async diagnostic() {
+        return run(() => migrate.devDiagnostic())
+      },
+      async push(force) {
+        return run(() => migrate.push({ force }))
+      },
+      async reset() {
+        return run(() => migrate.reset())
+      },
+      async schema(schema, force) {
+        const schemaContainer = toSchemasContainer([[prismaSchemaPath, schema]])
+
+        return run(() =>
+          migrate.engine.schemaPush({
+            force,
+            schema: schemaContainer,
+            filters: { externalEnums: [], externalTables: [] },
+          })
+        )
+      },
+    })
+  } finally {
+    await (migrate.engine as any).initPromise
+    const closePromise = new Promise<void>(resolve => {
+      ;(migrate.engine as any).child.once('exit', resolve)
+    })
+    migrate.stop()
+    await closePromise
+  }
+}

package/src/lib/otel.ts

@@ -0,0 +1,43 @@
+import { SpanStatusCode, trace, type AttributeValue, type Span } from '@opentelemetry/api'
+
+const tracer = trace.getTracer('nixxie')
+
+export function withSpanSync<T>(
+  name: string,
+  fn: (span: Span) => T,
+  attrs: Record<string, AttributeValue> = {}
+): T {
+  return tracer.startActiveSpan(name, { attributes: attrs }, span => {
+    try {
+      const result = fn(span)
+      span.setStatus({ code: SpanStatusCode.OK })
+      return result
+    } catch (err) {
+      span.recordException(err instanceof Error ? err : { message: String(err) })
+      span.setStatus({ code: SpanStatusCode.ERROR })
+      throw err
+    } finally {
+      span.end()
+    }
+  })
+}
+
+export async function withSpan<T>(
+  name: string,
+  fn: (span: Span) => Promise<T> | T,
+  attrs?: Record<string, AttributeValue>
+): Promise<T> {
+  return tracer.startActiveSpan(name, { attributes: attrs }, async span => {
+    try {
+      const result = await fn(span)
+      span.setStatus({ code: SpanStatusCode.OK })
+      return result
+    } catch (err) {
+      span.recordException(err instanceof Error ? err : { message: String(err) })
+      span.setStatus({ code: SpanStatusCode.ERROR })
+      throw err
+    } finally {
+      span.end()
+    }
+  })
+}

package/src/lib/prompts.ts

@@ -0,0 +1,29 @@
+import prompts from 'prompts'
+
+// prompts is badly typed so we have some more specific typed APIs
+// prompts also returns an undefined value on SIGINT which we really just want to exit on
+
+export async function confirmPrompt(message: string, initial: boolean = true): Promise<boolean> {
+  const { value } = await prompts({
+    name: 'value',
+    type: 'confirm',
+    message,
+    initial,
+  })
+  if (value === undefined) {
+    process.exit(1)
+  }
+  return value
+}
+
+export async function textPrompt(message: string): Promise<string> {
+  const { value } = await prompts({
+    name: 'value',
+    type: 'text',
+    message,
+  })
+  if (value === undefined) {
+    process.exit(1)
+  }
+  return value
+}

package/src/lib/system.ts

@@ -0,0 +1,207 @@
+import { randomBytes } from 'node:crypto'
+import path from 'node:path'
+
+import type { BaseNixxieTypeInfo, NixxieConfig, NixxieContext } from '../types'
+import { createAdminMeta } from './admin-meta'
+import { createContext } from './context/createContext'
+import { initialiseLists, type InitialisedList } from './core/initialise-lists'
+import { createGraphQLSchema } from './graphql'
+
+// TODO: this cannot be changed for now, circular dependency with getSystemPaths, getEsbuildConfig
+export function getBuiltNixxieConfigurationPath(cwd: string) {
+  return path.join(cwd, '.nixxie/config.js')
+}
+
+function posixify(s: string) {
+  return s.split(path.sep).join('/')
+}
+
+function getSystemPaths(cwd: string, config: NixxieConfig) {
+  const prismaClientPath =
+    config.db.prismaClientPath === '@prisma/client'
+      ? null
+      : config.db.prismaClientPath
+        ? path.join(cwd, config.db.prismaClientPath)
+        : null
+
+  const builtTypesPath = config.types?.path
+    ? path.join(cwd, config.types.path) // TODO: enforce initConfig before getSystemPaths
+    : path.join(cwd, 'node_modules/.nixxie/types.ts')
+
+  const builtPrismaPath = config.db?.prismaSchemaPath
+    ? path.join(cwd, config.db.prismaSchemaPath) // TODO: enforce initConfig before getSystemPaths
+    : path.join(cwd, 'schema.prisma')
+
+  const relativePrismaPath = prismaClientPath
+    ? `./${posixify(path.relative(path.dirname(builtTypesPath), prismaClientPath))}`
+    : '@prisma/client'
+
+  const builtGraphqlPath = config.graphql?.schemaPath
+    ? path.join(cwd, config.graphql.schemaPath) // TODO: enforce initConfig before getSystemPaths
+    : path.join(cwd, 'schema.graphql')
+
+  return {
+    config: getBuiltNixxieConfigurationPath(cwd),
+    admin: path.join(cwd, '.nixxie/admin'),
+    prisma: prismaClientPath ?? '@prisma/client',
+    types: {
+      relativePrismaPath,
+    },
+    schema: {
+      types: builtTypesPath,
+      prisma: builtPrismaPath,
+      graphql: builtGraphqlPath,
+    },
+  }
+}
+
+function getInternalGraphQLSchema(config: NixxieConfig) {
+  // omit `graphql.omit`
+  const withoutOmit: NixxieConfig = {
+    ...config,
+    lists: Object.fromEntries(
+      Object.entries(config.lists).map(([listKey, list]) => {
+        return [
+          listKey,
+          {
+            ...list,
+            graphql: { ...(list.graphql || {}), omit: false },
+            fields: Object.fromEntries(
+              Object.entries(list.fields).map(([fieldKey, field]) => {
+                if (fieldKey.startsWith('__group')) return [fieldKey, field]
+                return [
+                  fieldKey,
+                  data => {
+                    const f = field(data)
+                    return {
+                      ...f,
+                      graphql: { ...(f.graphql || {}), omit: false },
+
+                      // WARNING: this bypasses access control checks for filtering and ordering on the internal schema
+                      isFilterable: true, // TODO: remove when moved to .access.filter and .omit.filter
+                      isOrderable: true, // TODO: remove when moved to .access.filter and .omit.filter
+                    }
+                  },
+                ]
+              })
+            ),
+          },
+        ]
+      })
+    ),
+  }
+
+  const lists = initialiseLists(withoutOmit)
+  const adminMeta = createAdminMeta(withoutOmit, lists)
+  return createGraphQLSchema(withoutOmit, lists, adminMeta, true)
+}
+
+function injectNewDefaults(prismaClient: unknown, lists: Record<string, InitialisedList>) {
+  for (const listKey in lists) {
+    const list = lists[listKey]
+
+    // TODO: other fields might use 'random' too
+    const { dbField } = list.fields.id
+
+    if ('default' in dbField && dbField.default?.kind === 'random') {
+      const { bytes, encoding } = dbField.default
+
+      prismaClient = (prismaClient as any).$extends({
+        query: {
+          [list.prisma.listKey]: {
+            async create({ args, query }: any) {
+              return query({
+                ...args,
+                data: {
+                  ...args.data,
+                  id: args.data.id ?? randomBytes(bytes).toString(encoding),
+                },
+              })
+            },
+          },
+        },
+      })
+    }
+  }
+
+  return prismaClient
+}
+
+function formatUrl(provider: NixxieConfig['db']['provider'], url: string) {
+  if (url.startsWith('file:')) {
+    const parsed = new URL(url)
+    if (provider === 'sqlite' && !parsed.searchParams.get('connection_limit')) {
+      // https://github.com/prisma/prisma/issues/9562
+      // https://github.com/prisma/prisma/issues/10403
+      // https://github.com/prisma/prisma/issues/11789
+      parsed.searchParams.set('connection_limit', '1')
+
+      const [uri] = url.split('?')
+      return `${uri}?${parsed.search}`
+    }
+  }
+
+  return url
+}
+
+export function createSystem(config: NixxieConfig) {
+  const lists = initialiseLists(config)
+  const adminMeta = createAdminMeta(config, lists)
+  const graphQLSchemas = {
+    public: createGraphQLSchema(config, lists, adminMeta, false),
+    internal: getInternalGraphQLSchema(config),
+  }
+
+  return {
+    config,
+    graphql: {
+      schemas: graphQLSchemas,
+    },
+    adminMeta,
+    lists,
+    getPaths: (cwd: string) => getSystemPaths(cwd, config),
+
+    getNixxie: (PM: any) => {
+      const prePrismaClient = new PM.PrismaClient({
+        datasourceUrl: formatUrl(config.db.provider, config.db.url),
+        log: config.db.enableLogging,
+      })
+
+      const prismaClient = config.db.extendPrismaClient(injectNewDefaults(prePrismaClient, lists))
+      const context = createContext({
+        config,
+        lists,
+        graphQLSchemas,
+        prismaClient,
+        prismaTypes: {
+          DbNull: PM.Prisma.DbNull,
+          JsonNull: PM.Prisma.JsonNull,
+        },
+      })
+
+      return {
+        // TODO: replace with server.onStart, remove in breaking change
+        async connect() {
+          await (prismaClient as any).$connect()
+          await config.db.onConnect?.(context)
+        },
+        // TODO: only used by tests, remove in breaking change
+        async disconnect() {
+          await (prismaClient as any).$disconnect()
+        },
+        context,
+      }
+    },
+  }
+}
+
+export type System = ReturnType<typeof createSystem>
+
+export function getContext<TypeInfo extends BaseNixxieTypeInfo>(
+  config: NixxieConfig<TypeInfo>,
+  PrismaModule: unknown
+): NixxieContext<TypeInfo> {
+  const system = createSystem(config)
+  const { context } = system.getNixxie(PrismaModule)
+  return context
+}