@nixxie-cms/core 1.0.0

package/src/scripts/migrate.ts

@@ -0,0 +1,214 @@
+import { spawn } from 'node:child_process'
+import { randomBytes } from 'node:crypto'
+import { join } from 'node:path'
+
+import chalk from 'chalk'
+import esbuild from 'esbuild'
+import fse from 'fs-extra'
+
+import { withMigrate } from '../lib/migrations'
+import { confirmPrompt, textPrompt } from '../lib/prompts'
+import { createSystem } from '../lib/system'
+import { getEsbuildConfig } from './esbuild'
+
+import { createDatabase, dropDatabase } from '@prisma/internals'
+import {
+  generateArtifacts,
+  generatePrismaClient,
+  generateTypes,
+  validateArtifacts,
+} from '../artifacts'
+import type { Flags } from './cli'
+import { ExitError, importBuiltNixxieConfiguration } from './utils'
+
+export async function spawnPrisma(
+  cwd: string,
+  system: {
+    config: {
+      db: {
+        url: string
+      }
+    }
+  },
+  commands: string[]
+) {
+  let output = ''
+  return new Promise<{
+    exitCode: number | null
+    output: string
+  }>((resolve, reject) => {
+    const p = spawn(
+      'node',
+      ['--title=prisma', require.resolve('prisma/build/index.js'), ...commands],
+      {
+        cwd,
+        env: {
+          ...process.env,
+          DATABASE_URL: system.config.db.url,
+          PRISMA_HIDE_UPDATE_MESSAGE: '1',
+        },
+      }
+    )
+    p.stdout.on('data', data => (output += data.toString('utf-8')))
+    p.stderr.on('data', data => (output += data.toString('utf-8')))
+    p.on('error', err => reject(err))
+    p.on('exit', exitCode => resolve({ exitCode, output }))
+  })
+}
+
+export async function migrateCreate(
+  cwd: string,
+  { frozen, quiet }: Pick<Flags, 'frozen' | 'quiet'>
+) {
+  function log(message: string) {
+    if (quiet) return
+    console.log(message)
+  }
+
+  await esbuild.build(await getEsbuildConfig(cwd))
+
+  const system = createSystem(await importBuiltNixxieConfiguration(cwd))
+  if (frozen) {
+    await validateArtifacts(cwd, system)
+    log('✨ GraphQL and Prisma schemas are up to date')
+  } else {
+    await generateArtifacts(cwd, system)
+    log('✨ Generated GraphQL and Prisma schemas')
+  }
+
+  await generateTypes(cwd, system)
+  await generatePrismaClient(cwd, system)
+
+  // TODO: remove, should be Prisma
+  await fse.outputFile(
+    join(cwd, 'migrations/migration_lock.toml'),
+    `Please do not edit this file manually
+//  # It should be added in your version-control system (i.e. Git)
+provider = ${system.config.db.provider}`
+  )
+  // TODO: remove, should be Prisma
+  let deleteShadowDatabase = async () => {}
+  let shadowDatabaseUrl = system.config.db.shadowDatabaseUrl
+  if (system.config.db.provider !== 'sqlite' && !shadowDatabaseUrl) {
+    const parsedUrl = new URL(system.config.db.url)
+    parsedUrl.pathname = `ktmp${Date.now()}_${randomBytes(6).toString('hex')}`
+    shadowDatabaseUrl = parsedUrl.toString()
+    try {
+      await createDatabase(shadowDatabaseUrl)
+    } catch (err) {
+      console.error(err)
+      console.error(
+        chalk.red('Failed to create shadow database, db.shadowDatabaseUrl may be required')
+      )
+      throw new ExitError(1)
+    }
+    deleteShadowDatabase = async () => {
+      await dropDatabase(shadowDatabaseUrl)
+    }
+  }
+  let sql
+  try {
+    const paths = system.getPaths(cwd)
+    const { output: summary, exitCode: prismaExitCode } = await spawnPrisma(cwd, system, [
+      'migrate',
+      'diff',
+      ...(shadowDatabaseUrl ? ['--shadow-database-url', shadowDatabaseUrl] : []),
+      '--from-migrations',
+      'migrations/',
+      '--to-schema-datamodel',
+      paths.schema.prisma,
+    ])
+
+    if (typeof prismaExitCode === 'number' && prismaExitCode !== 0) {
+      console.error(summary)
+      throw new ExitError(prismaExitCode)
+    }
+
+    if (summary.startsWith('No difference detected')) {
+      log('🔄 Database unchanged from Prisma schema')
+      throw new ExitError(0)
+    }
+
+    console.error(summary)
+    const { output, exitCode: prismaExitCode2 } = await spawnPrisma(cwd, system, [
+      'migrate',
+      'diff',
+      ...(shadowDatabaseUrl ? ['--shadow-database-url', shadowDatabaseUrl] : []),
+      '--from-migrations',
+      'migrations/',
+      '--to-schema-datamodel',
+      paths.schema.prisma,
+      '--script',
+    ])
+    sql = output
+
+    if (typeof prismaExitCode2 === 'number' && prismaExitCode2 !== 0) {
+      console.error(sql)
+      throw new ExitError(prismaExitCode2)
+    }
+  } finally {
+    await deleteShadowDatabase()
+  }
+
+  const prefix = new Date()
+    .toLocaleString('sv-SE')
+    .replace(/[^0-9]/g, '')
+    .slice(0, 14)
+
+  // https://github.com/prisma/prisma/blob/183c14d2aa6059fc3c00c95363887e8941b3d911/packages/migrate/src/utils/promptForMigrationName.ts#L12
+  //   Prisma truncates >200 characters
+  const name = (await textPrompt('Name of migration')).replace(/[^A-Za-z0-9_]/g, '_').slice(0, 200)
+  const path = join(`migrations`, `${prefix}_${name}/migration.sql`)
+
+  await fse.outputFile(join(cwd, path), sql)
+  log(`✨ Generated SQL migration at ${path}`)
+}
+
+export async function migrateApply(
+  cwd: string,
+  { frozen, quiet }: Pick<Flags, 'frozen' | 'quiet'>
+) {
+  function log(message: string) {
+    if (quiet) return
+    console.log(message)
+  }
+
+  // TODO: should this happen if frozen?
+  await esbuild.build(await getEsbuildConfig(cwd))
+
+  const system = createSystem(await importBuiltNixxieConfiguration(cwd))
+  if (frozen) {
+    await validateArtifacts(cwd, system)
+    log('✨ GraphQL and Prisma schemas are up to date')
+  } else {
+    await generateArtifacts(cwd, system)
+    log('✨ Generated GraphQL and Prisma schemas')
+  }
+
+  await generateTypes(cwd, system)
+  await generatePrismaClient(cwd, system)
+
+  log('✨ Applying any database migrations')
+  const paths = system.getPaths(cwd)
+  const { appliedMigrationNames } = await withMigrate(paths.schema.prisma, system, async m => {
+    const diagnostic = await m.diagnostic()
+
+    if (diagnostic.action.tag === 'reset') {
+      console.error(diagnostic.action.reason)
+      const consent = await confirmPrompt(
+        `Do you want to continue? ${chalk.red('The database will be reset')}`
+      )
+      if (!consent) throw new ExitError(1, 'Database reset cancelled by user')
+
+      await m.reset()
+    }
+
+    return await m.apply()
+  })
+
+  log(
+    appliedMigrationNames.length === 0
+      ? `✨ No database migrations to apply`
+      : `✨ Database migrated`
+  )
+}

package/src/scripts/prisma.ts

@@ -0,0 +1,49 @@
+import { spawn } from 'node:child_process'
+
+import { validateArtifacts } from '../artifacts'
+import { createSystem } from '../lib/system'
+import { ExitError, importBuiltNixxieConfiguration } from './utils'
+
+async function spawnPrisma3(
+  cwd: string,
+  system: {
+    config: {
+      db: {
+        url: string
+      }
+    }
+  },
+  commands: string[]
+) {
+  return new Promise<{
+    exitCode: number | null
+  }>((resolve, reject) => {
+    const p = spawn(
+      'node',
+      ['--title=prisma', require.resolve('prisma/build/index.js'), ...commands],
+      {
+        cwd,
+        env: {
+          ...process.env,
+          DATABASE_URL: system.config.db.url,
+          PRISMA_HIDE_UPDATE_MESSAGE: '1',
+        },
+        stdio: 'inherit',
+      }
+    )
+    p.on('error', err => reject(err))
+    p.on('exit', exitCode => resolve({ exitCode }))
+  })
+}
+
+export async function prisma(cwd: string, args: string[], frozen: boolean) {
+  // TODO: should build unless --frozen?
+
+  const system = createSystem(await importBuiltNixxieConfiguration(cwd))
+  await validateArtifacts(cwd, system)
+
+  const { exitCode } = await spawnPrisma3(cwd, system, args)
+  if (typeof exitCode === 'number' && exitCode !== 0) {
+    throw new ExitError(exitCode)
+  }
+}

package/src/scripts/start.ts

@@ -0,0 +1,76 @@
+import next from 'next'
+
+import { createSystem } from '../lib/system'
+import { createExpressServer } from '../lib/express'
+import { createAdminUIMiddlewareWithNextApp } from '../lib/middleware'
+import { withMigrate } from '../lib/migrations'
+import type { Flags } from './cli'
+import { importBuiltNixxieConfiguration } from './utils'
+
+export async function start(
+  cwd: string,
+  { quiet, server, ui, withMigrations }: Pick<Flags, 'quiet' | 'server' | 'ui' | 'withMigrations'>
+) {
+  function log(message: string) {
+    if (quiet) return
+    console.log(message)
+  }
+  log('✨ Starting Nixxie')
+
+  const system = createSystem(await importBuiltNixxieConfiguration(cwd))
+  const paths = system.getPaths(cwd)
+
+  if (withMigrations) {
+    log('✨ Applying any database migrations')
+    const { appliedMigrationNames } = await withMigrate(paths.schema.prisma, system, m => m.apply())
+    log(
+      appliedMigrationNames.length === 0
+        ? `✨ No database migrations to apply`
+        : `✨ Database migrated`
+    )
+  }
+
+  if (!server) return
+
+  const prismaClient = require(paths.prisma)
+  const nixxie = system.getNixxie(prismaClient)
+
+  log('✨ Connecting to the database')
+  await nixxie.connect()
+
+  log('✨ Creating server')
+  const { expressServer, httpServer } = await createExpressServer(system.config, nixxie.context)
+
+  log(`✅ GraphQL API ready`)
+  if (!system.config.ui?.isDisabled && ui) {
+    log('✨ Preparing Admin UI')
+    const nextApp = next({ dev: false, dir: paths.admin })
+    await nextApp.prepare()
+    expressServer.use(createAdminUIMiddlewareWithNextApp(system.config, nixxie.context, nextApp))
+    log(`✅ Admin UI ready`)
+  }
+
+  const httpOptions = system.config.server.options
+
+  // prefer env.PORT
+  if ('PORT' in process.env) {
+    httpOptions.port = parseInt(process.env.PORT || '')
+  }
+
+  // prefer env.HOST
+  if ('HOST' in process.env) {
+    httpOptions.host = process.env.HOST || ''
+  }
+
+  httpServer.listen(system.config.server.options, (err?: any) => {
+    if (err) throw err
+
+    const easyHost = [undefined, '', '::', '0.0.0.0'].includes(httpOptions.host)
+      ? 'localhost'
+      : httpOptions.host
+
+    log(
+      `⭐️ Server listening on ${httpOptions.host || ''}:${httpOptions.port} (http://${easyHost}:${httpOptions.port}/)`
+    )
+  })
+}

package/src/scripts/telemetry.ts

@@ -0,0 +1,37 @@
+import { bold } from 'chalk'
+import {
+  disableTelemetry,
+  enableTelemetry,
+  informTelemetry,
+  resetTelemetry,
+  statusTelemetry,
+} from '../lib/telemetry'
+
+export async function telemetry(_: string, command?: string) {
+  const usageText = `
+    Usage
+      $ nixxie telemetry [command]
+    Commands
+      disable     opt-out of telemetry, disabling telemetry for this system user
+      enable      opt-in to telemetry
+      reset       resets your telemetry configuration (if any)
+      status      show if telemetry is enabled, disabled or uninitialised
+      inform      show an informed consent notice
+
+For more details visit: https://nixxiecms.com/telemetry
+    `
+
+  if (command === 'disable') return disableTelemetry()
+  if (command === 'enable') return enableTelemetry()
+  if (command === 'reset') return resetTelemetry()
+  if (command === 'status') return statusTelemetry()
+  if (command === 'inform') return informTelemetry()
+  if (command === '--help') {
+    console.error(`${bold('Nixxie Telemetry')}`)
+    console.error(usageText)
+    return
+  }
+
+  console.error(command ? `Invalid option: ${command}` : '')
+  console.error(usageText)
+}

package/src/scripts/utils.ts

@@ -0,0 +1,22 @@
+import fs from 'node:fs/promises'
+
+import { getBuiltNixxieConfigurationPath } from '../lib/system'
+import type { NixxieConfig } from '../types'
+
+export class ExitError extends Error {
+  code: number
+  constructor(code: number, message: string = '') {
+    super(`The process exited with ${code}${message ? `: ${message}` : ''}`)
+    this.code = code
+    this.message = message
+  }
+}
+
+// TODO: this cannot be changed for now, circular dependency with getSystemPaths, getEsbuildConfig
+export async function importBuiltNixxieConfiguration(cwd: string): Promise<NixxieConfig> {
+  const builtConfigPath = getBuiltNixxieConfigurationPath(cwd)
+  if (!(await fs.stat(builtConfigPath).catch(() => null))) {
+    throw new Error('You need to run "nixxie build"')
+  }
+  return require(builtConfigPath).default
+}

package/src/session.ts

@@ -0,0 +1,168 @@
+import { randomBytes } from 'node:crypto'
+import * as cookie from 'cookie'
+import Iron from '@hapi/iron'
+import type { NixxieContext, SessionStrategy, SessionStoreFunction } from '../types'
+
+// TODO: should we also accept httpOnly?
+type StatelessSessionsOptions = {
+  /**
+   * Secret used by https://github.com/hapijs/iron for encapsulating data. Must be at least 32 characters long
+   */
+  secret?: string
+  /**
+   * Iron seal options for customizing the key derivation algorithm used to generate encryption and integrity verification keys as well as the algorithms and salt sizes used.
+   * See https://hapi.dev/module/iron/api/?v=6.0.0#options for available options.
+   *
+   * @default Iron.defaults
+   */
+  ironOptions?: Iron.SealOptions
+  /**
+   * Specifies the number (in seconds) to be the value for the `Max-Age`
+   * `Set-Cookie` attribute.
+   *
+   * @default 60 * 60 * 8 // 8 hours
+   */
+  maxAge?: number
+  /**
+   * The name of the cookie used by `Set-Cookie`.
+   *
+   * @default nixxiecms-session
+   */
+  cookieName?: string
+  /**
+   * Specifies the boolean value for the [`Secure` `Set-Cookie` attribute](https://tools.ietf.org/html/rfc6265#section-5.2.5).
+   *
+   * *Note* be careful when setting this to `true`, as compliant clients will
+   * not send the cookie back to the server in the future if the browser does
+   * not have an HTTPS connection.
+   *
+   * @default process.env.NODE_ENV === 'production'
+   */
+  secure?: boolean
+  /**
+   * Specifies the value for the [`Path` `Set-Cookie` attribute](https://tools.ietf.org/html/rfc6265#section-5.2.4).
+   *
+   * @default '/'
+   */
+  path?: string
+  /**
+   * Specifies the domain for the [`Domain` `Set-Cookie` attribute](https://tools.ietf.org/html/rfc6265#section-5.2.3)
+   *
+   * @default current domain
+   */
+  domain?: string
+  /**
+   * Specifies the boolean or string to be the value for the [`SameSite` `Set-Cookie` attribute](https://tools.ietf.org/html/draft-ietf-httpbis-rfc6265bis-03#section-4.1.2.7).
+   *
+   * @default 'lax'
+   */
+  sameSite?: true | false | 'lax' | 'strict' | 'none'
+}
+
+function getToken(req: NonNullable<NixxieContext['req']>, cookieName: string) {
+  const authorization = req.headers.authorization ?? ''
+
+  if (authorization.startsWith('Bearer')) {
+    return authorization.slice('Bearer '.length)
+  }
+
+  const cookies = cookie.parse(req.headers.cookie || '')
+  return cookies[cookieName]
+}
+
+export function statelessSessions<Session>({
+  secret = randomBytes(32).toString('base64url'),
+  maxAge = 60 * 60 * 8, // 8 hours,
+  cookieName = 'nixxiecms-session',
+  path = '/',
+  secure = process.env.NODE_ENV === 'production',
+  ironOptions = Iron.defaults,
+  domain,
+  sameSite = 'lax',
+}: StatelessSessionsOptions = {}) {
+  // atleast 192-bit in base64
+  if (secret.length < 32) {
+    throw new Error('The session secret must be at least 32 characters long')
+  }
+
+  return {
+    async get({ context }) {
+      if (!context?.req) return
+
+      const token = getToken(context.req, cookieName)
+      if (!token) return
+      try {
+        return await Iron.unseal(token, secret, ironOptions)
+      } catch (err) {
+        // do nothing
+      }
+    },
+    async end({ context }) {
+      if (!context?.res) return
+
+      context.res.setHeader(
+        'Set-Cookie',
+        cookie.serialize(cookieName, '', {
+          maxAge: 0,
+          expires: new Date(),
+          httpOnly: true,
+          secure,
+          path,
+          sameSite,
+          domain,
+        })
+      )
+    },
+    async start({ context, data }) {
+      if (!context?.res) return
+
+      const sealedData = await Iron.seal(data, secret, { ...ironOptions, ttl: maxAge * 1000 })
+      context.res.setHeader(
+        'Set-Cookie',
+        cookie.serialize(cookieName, sealedData, {
+          maxAge,
+          expires: new Date(Date.now() + maxAge * 1000),
+          httpOnly: true,
+          secure,
+          path,
+          sameSite,
+          domain,
+        })
+      )
+
+      return sealedData
+    },
+  } satisfies SessionStrategy<Session, any>
+}
+
+export function storedSessions<Session>({
+  store: storeFn,
+  maxAge = 60 * 60 * 8, // 8 hours
+  ...statelessSessionsOptions
+}: {
+  store: SessionStoreFunction<Session>
+} & StatelessSessionsOptions) {
+  const stateless = statelessSessions<string>({ ...statelessSessionsOptions, maxAge })
+  const store = storeFn({ maxAge })
+
+  return {
+    async get({ context }) {
+      const sessionId = await stateless.get({ context })
+      if (!sessionId) return
+
+      return store.get(sessionId)
+    },
+    async start({ context, data }) {
+      const sessionId = randomBytes(24).toString('base64url') // 192-bit
+      await store.set(sessionId, data)
+      return stateless.start({ context, data: sessionId }) || ''
+    },
+    async end({ context }) {
+      const sessionId = await stateless.get({ context })
+      if (!sessionId) return
+
+      await store.delete(sessionId)
+      await stateless.end({ context })
+    },
+  } satisfies SessionStrategy<Session, any>
+}

package/src/testing.ts

@@ -0,0 +1,23 @@
+import path from 'node:path'
+import { createDatabase } from '@prisma/internals'
+
+import { withMigrate } from './lib/migrations'
+
+export async function resetDatabase(url: string, prismaSchemaPath: string) {
+  await createDatabase(url, path.dirname(prismaSchemaPath))
+  await withMigrate(
+    prismaSchemaPath,
+    {
+      config: {
+        db: {
+          url,
+          shadowDatabaseUrl: '',
+        },
+      },
+    },
+    async m => {
+      await m.reset()
+      await m.push(true)
+    }
+  )
+}