@nixxie-cms/core 1.0.0

package/src/schema.ts

@@ -0,0 +1,233 @@
+import type { ListenOptions } from 'node:net'
+
+import { idFieldType } from './lib/id-field'
+import type {
+  Action,
+  ActionArgsConfig,
+  BaseFields,
+  BaseNixxieTypeInfo,
+  BaseListTypeInfo,
+  DeclaredAction,
+  IdFieldConfig,
+  NixxieConfig,
+  NixxieConfigPre,
+  NixxieContext,
+  ListConfig,
+  MaybeItemFunctionWithFilter,
+  MaybeSessionFunction,
+  MaybeSessionFunctionWithFilter,
+} from './types'
+
+function listsWithDefaults(config: NixxieConfigPre, defaultIdField: IdFieldConfig) {
+  // some error checking
+  for (const [listKey, list] of Object.entries(config.lists)) {
+    if (list.fields.id) {
+      throw new Error(
+        `"fields.id" is reserved by Nixxie, use "db.idField" for the "${listKey}" list`
+      )
+    }
+
+    if (list.isSingleton && list.db?.idField) {
+      throw new Error(`"db.idField" on the "${listKey}" list conflicts with singleton defaults`)
+    }
+  }
+
+  return Object.fromEntries([
+    ...(function* () {
+      for (const [listKey, list] of Object.entries(config.lists)) {
+        yield [
+          listKey,
+          {
+            listKey,
+            defaultIsFilterable: true, // TODO: move to access control?
+            defaultIsOrderable: true, // TODO: move to access control?
+            isSingleton: false,
+            ...list,
+            db: {
+              ...list.db,
+            },
+            fields: {
+              ...(list.isSingleton
+                ? {
+                    id: idFieldType({ kind: 'number', type: 'Int' }),
+                    ...list.fields,
+                  }
+                : {
+                    id: idFieldType(list.db?.idField ?? defaultIdField),
+                    ...list.fields,
+                  }),
+            },
+            actions: {
+              ...list.actions,
+            },
+            hooks: {
+              ...list.hooks,
+            },
+            graphql: {
+              ...list.graphql,
+            },
+            ui: {
+              ...list.ui,
+            },
+          } satisfies NixxieConfig['lists'][string],
+        ]
+      }
+    })(),
+  ]) satisfies NixxieConfig['lists']
+}
+
+function defaultIsAccessAllowed({ session, sessionStrategy }: NixxieContext) {
+  if (!sessionStrategy) return true
+  return session !== undefined
+}
+
+async function noop() {}
+function identity<T>(x: T) {
+  return x
+}
+
+export function config<TypeInfo extends BaseNixxieTypeInfo>(
+  config: NixxieConfigPre<TypeInfo>
+): NixxieConfig<TypeInfo> {
+  if (!['postgresql', 'sqlite', 'mysql'].includes(config.db.provider)) {
+    throw new TypeError(`"db.provider" only supports "sqlite", "postgresql" or "mysql"`)
+  }
+
+  // WARNING: Typescript should prevent this, but any string is useful for Prisma errors
+  config.db.url ??= 'postgres://'
+
+  const defaultIdField = config.db.idField ?? { kind: 'cuid' }
+  const cors =
+    config.server?.cors === true
+      ? { origin: true, credentials: true }
+      : config.server?.cors === false
+        ? null
+        : (config.server?.cors ?? null)
+
+  const httpOptions: ListenOptions = { port: 3000 }
+  if (config?.server && 'port' in config.server) {
+    httpOptions.port = config.server.port
+  }
+
+  if (config?.server && 'options' in config.server && config.server.options) {
+    Object.assign(httpOptions, config.server.options)
+  }
+
+  return {
+    types: {
+      ...config.types,
+      path: config.types?.path ?? 'node_modules/.nixxie/types.ts',
+    },
+    db: {
+      ...config.db,
+      shadowDatabaseUrl: config.db?.shadowDatabaseUrl ?? '',
+      extendPrismaSchema: config.db?.extendPrismaSchema ?? identity,
+      extendPrismaClient: config.db?.extendPrismaClient ?? identity,
+      onConnect: config.db.onConnect ?? noop,
+      prismaClientPath: config.db?.prismaClientPath ?? '@prisma/client',
+      prismaSchemaPath: config.db?.prismaSchemaPath ?? 'schema.prisma',
+      idField: config.db?.idField ?? defaultIdField,
+      enableLogging:
+        config.db.enableLogging === true
+          ? ['query']
+          : config.db.enableLogging === false
+            ? []
+            : (config.db.enableLogging ?? []),
+    },
+    graphql: {
+      ...config.graphql,
+      path: config.graphql?.path ?? '/api/graphql',
+      playground: config.graphql?.playground ?? process.env.NODE_ENV !== 'production',
+      schemaPath: config.graphql?.schemaPath ?? 'schema.graphql',
+      extendGraphqlSchema: config.graphql?.extendGraphqlSchema ?? (s => s),
+    },
+    lists: listsWithDefaults(config, defaultIdField),
+    server: {
+      ...config.server,
+      maxFileSize: config.server?.maxFileSize ?? 200 * 1024 * 1024, // 200 MiB
+      extendExpressApp: config.server?.extendExpressApp ?? noop,
+      extendHttpServer: config.server?.extendHttpServer ?? noop,
+      cors,
+      options: httpOptions,
+    },
+    session: config.session,
+    email: config.email,
+    jobs: config.jobs,
+    cache: config.cache,
+    audit: config.audit,
+    webhooks: config.webhooks,
+    rateLimit: config.rateLimit,
+    health: config.health,
+    telemetry: config.telemetry ?? true,
+    ui: {
+      ...config.ui,
+      basePath: config.ui?.basePath ?? '',
+      isAccessAllowed: config.ui?.isAccessAllowed ?? defaultIsAccessAllowed,
+      isDisabled: config.ui?.isDisabled ?? false,
+      getAdditionalFiles: config.ui?.getAdditionalFiles ?? (() => []),
+      pageMiddleware: config.ui?.pageMiddleware ?? noop,
+      publicPages: config.ui?.publicPages ?? [],
+    },
+  }
+}
+
+let i = 0
+
+export type GroupInfo<ListTypeInfo extends BaseListTypeInfo> = {
+  fields: string[]
+  label: string
+  description: string
+  ui: GroupUIConfig<ListTypeInfo> | undefined
+}
+
+type GroupUIConfig<ListTypeInfo extends BaseListTypeInfo> = {
+  createView?: {
+    defaultFieldMode?: MaybeSessionFunctionWithFilter<'hidden' | 'edit', 'hidden', ListTypeInfo>
+  }
+  itemView?: {
+    defaultFieldMode?: MaybeItemFunctionWithFilter<
+      'edit' | 'hidden' | 'read',
+      'hidden' | 'read',
+      ListTypeInfo
+    >
+  }
+  listView?: {
+    defaultFieldMode?: MaybeSessionFunction<'read' | 'hidden', ListTypeInfo>
+  }
+}
+
+export function group<ListTypeInfo extends BaseListTypeInfo>(config: {
+  label: string
+  description?: string
+  ui?: GroupUIConfig<ListTypeInfo>
+  fields: BaseFields<ListTypeInfo>
+}) {
+  const keys = Object.keys(config.fields)
+  if (keys.some(key => key.startsWith('__group'))) {
+    throw new Error('groups cannot be nested')
+  }
+
+  return {
+    [`__group${i++}`]: {
+      fields: keys,
+      label: config.label,
+      description: config.description ?? '',
+      ui: config.ui,
+    } satisfies GroupInfo<ListTypeInfo>,
+    ...config.fields,
+  } as BaseFields<ListTypeInfo> // TODO: FIXME, see initialise-lists.ts:getListsWithInitialisedFields
+}
+
+export function list<ListTypeInfo extends BaseListTypeInfo>(listConfig: ListConfig<ListTypeInfo>) {
+  return { ...listConfig }
+}
+
+export function action<
+  ListTypeInfo extends BaseListTypeInfo,
+  Args extends ActionArgsConfig<ListTypeInfo> | undefined = undefined,
+>(action: Action<ListTypeInfo, Args>): DeclaredAction<ListTypeInfo> {
+  return {
+    ...action,
+    ___defineActionsWithActionFunction: true,
+  } as unknown as DeclaredAction<ListTypeInfo>
+}

package/src/scripts/build.ts

@@ -0,0 +1,64 @@
+import esbuild from 'esbuild'
+import { generateAdminUI } from '../admin-ui/system'
+import {
+  generateArtifacts,
+  generatePrismaClient,
+  generateTypes,
+  validateArtifacts,
+} from '../artifacts'
+import { createSystem } from '../lib/system'
+import type { Flags } from './cli'
+import { getEsbuildConfig } from './esbuild'
+import { importBuiltNixxieConfiguration } from './utils'
+
+export async function build(
+  cwd: string,
+  { frozen, prisma, quiet, ui }: Pick<Flags, 'frozen' | 'prisma' | 'quiet' | 'ui'>
+) {
+  function log(message: string) {
+    if (quiet) return
+    console.log(message)
+  }
+
+  // log('✨ Building Nixxie configuration')
+  await esbuild.build(await getEsbuildConfig(cwd))
+
+  const system = createSystem(await importBuiltNixxieConfiguration(cwd))
+  if (prisma) {
+    if (frozen) {
+      await validateArtifacts(cwd, system)
+      log('✨ GraphQL and Prisma schemas are up to date') // TODO: validating?
+    } else {
+      await generateArtifacts(cwd, system)
+      log('✨ Generated GraphQL and Prisma schemas') // TODO: generating?
+    }
+
+    await generateTypes(cwd, system)
+    await generatePrismaClient(cwd, system)
+  }
+
+  if (system.config.ui?.isDisabled || !ui) return
+
+  log('✨ Generating Admin UI code')
+  const paths = system.getPaths(cwd)
+  await generateAdminUI(system.config, system.adminMeta, paths.admin, false)
+
+  log('✨ Building Admin UI')
+
+  // do _NOT_ change this to a static import, it is intentionally like this
+  // to avoid loading it in the common case where the UI is not being built
+  // eslint-disable-next-line @typescript-eslint/consistent-type-imports
+  const nextBuild = require('next/dist/build').default as typeof import('next/dist/build').default
+  await nextBuild(
+    paths.admin,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    'default',
+    undefined
+  )
+}

package/src/scripts/cli.ts

@@ -0,0 +1,124 @@
+import meow from 'meow'
+import { build } from './build'
+import { dev } from './dev'
+import { migrateApply, migrateCreate } from './migrate'
+import { prisma } from './prisma'
+import { start } from './start'
+import { telemetry } from './telemetry'
+import { ExitError } from './utils'
+
+export type Flags = {
+  dbPush: boolean
+  frozen: boolean
+  prisma: boolean
+  server: boolean
+  quiet: boolean
+  ui: boolean
+  withMigrations: boolean
+}
+
+function defaultFlags(flags: Partial<Flags>, defaults: Partial<Flags>) {
+  flags = { ...defaults, ...flags }
+
+  for (const [key, value] of Object.entries(flags)) {
+    if (value !== undefined && !(key in defaults)) {
+      // TODO: maybe we should prevent other flags?
+      //throw new Error(`Option '${key}' is unsupported for this command`);
+      continue
+    }
+
+    const defaultValue = defaults[key as keyof Flags]
+    // should we default the flag?
+    if (value === undefined) {
+      flags[key as keyof Flags] = defaultValue
+    }
+
+    if (typeof value !== typeof defaultValue) {
+      throw new Error(`Option '${key}' should be of type ${typeof defaultValue}`)
+    }
+  }
+  return flags as Flags
+}
+
+export async function cli(cwd: string, argv: string[]) {
+  const { input, help, flags } = meow(
+    `
+    Usage
+      $ nixxie [command] [options]
+
+    Commands
+        dev             start the project in development mode (default)
+        migrate create  build the project for development and create a migration from the Prisma diff
+        migrate apply   build the project for development and apply any pending migrations
+        postinstall     build the project for development
+        build           build the project (required by \`nixxie start\` and \`nixxie prisma\`)
+        telemetry       sets telemetry preference (enable/disable/status)
+
+        start           start the project
+        prisma          use prisma commands in a Nixxie context
+
+    Options
+      --frozen (build, migrate)
+        don't build the graphql or prisma schemas, only validate them
+
+      --no-db-push (dev)
+        don't push any updates of your Prisma schema to your database
+
+      --no-prisma (build, dev)
+        don't build or validate the prisma schema
+
+      --no-server (dev, start)
+        don't start the express server
+
+      --no-ui (build, dev, start)
+        don't build and serve the AdminUI
+
+      --with-migrations (start)
+        trigger prisma to run migrations as part of startup
+    `,
+    {
+      argv,
+    }
+  )
+
+  const command = input.join(' ') || 'dev'
+
+  if (command === 'dev') {
+    return dev(cwd, defaultFlags(flags, { dbPush: true, prisma: true, server: true, ui: true }))
+  }
+
+  if (command === 'migrate create') {
+    return migrateCreate(cwd, defaultFlags(flags, { ui: false }))
+  }
+
+  if (command === 'migrate apply') {
+    return migrateApply(cwd, defaultFlags(flags, { ui: false }))
+  }
+
+  if (command === 'build') {
+    return build(cwd, defaultFlags(flags, { frozen: false, prisma: true, ui: true }))
+  }
+
+  if (command === 'start') {
+    return start(cwd, defaultFlags(flags, { server: true, ui: true, withMigrations: false }))
+  }
+
+  if (command.startsWith('prisma')) {
+    return prisma(cwd, argv.slice(1), Boolean(flags.frozen))
+  }
+
+  if (command.startsWith('telemetry')) {
+    return telemetry(cwd, argv[1])
+  }
+
+  // WARNING: postinstall is an alias for `build --frozen --no-ui`
+  if (command === 'postinstall') {
+    // uncomment when you need to update the schemas
+    // return build(cwd, defaultFlags(flags, { frozen: false, prisma: true, ui: false }))
+    return build(cwd, defaultFlags(flags, { frozen: true, prisma: true, ui: false }))
+  }
+
+  console.error(`${command} is an unknown command`)
+  console.error(help)
+  throw new ExitError(1)
+}