@nixxie-cms/core 1.0.0

package/scripts/cli/dist/nixxie-cms-core-scripts-cli.cjs.js

@@ -0,0 +1,1607 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var meow = require('meow');
+var esbuild = require('esbuild');
+var fs_walk = require('@nodelib/fs.walk');
+var fse = require('fs-extra');
+var fs = require('node:fs/promises');
+var path = require('node:path');
+var node_util = require('node:util');
+var resolve = require('resolve');
+var system = require('../../../dist/system-48c5f6df.cjs.js');
+var express = require('../../../dist/express-e9ed9a7d.cjs.js');
+var node_module = require('node:module');
+var node_http = require('node:http');
+var internals = require('@prisma/internals');
+var chalk = require('chalk');
+var express$1 = require('express');
+var graphql = require('graphql');
+var next = require('next');
+var path$1 = require('path');
+var migrations = require('../../../dist/migrations-ab2e0fd4.cjs.js');
+var prompts = require('prompts');
+var node_os = require('node:os');
+var https = require('node:https');
+var ci = require('ci-info');
+var Conf = require('conf');
+var node_child_process = require('node:child_process');
+var node_crypto = require('node:crypto');
+require('../../../dist/admin-meta-18d0c276.cjs.js');
+require('@graphql-ts/schema');
+require('../../../dist/resolve-hooks-66fe8a8e.cjs.js');
+require('pluralize');
+require('../../../dist/next-fields-49c025ef.cjs.js');
+require('decimal.js');
+require('@graphql-ts/extend');
+require('graphql-upload/GraphQLUpload.js');
+require('../../../dist/utils-e74e3527.cjs.js');
+require('../../../dist/utils-1b632a8f.cjs.js');
+require('../../../access/dist/nixxie-cms-core-access.cjs.js');
+require('graphql/execution/values');
+require('../../../dist/utils-b031e11c.cjs.js');
+require('@apollo/cache-control-types');
+require('dataloader');
+require('@babel/runtime/helpers/classPrivateFieldInitSpec');
+require('@babel/runtime/helpers/classPrivateFieldGet2');
+require('@babel/runtime/helpers/classPrivateFieldSet2');
+require('@opentelemetry/api');
+require('@prisma/client-generator-registry');
+require('http');
+require('cors');
+require('body-parser');
+require('@apollo/server/express4');
+require('@apollo/server');
+require('@apollo/server/plugin/disabled');
+require('@apollo/server/plugin/landingPage/default');
+require('graphql-upload/graphqlUploadExpress.js');
+require('@prisma/migrate');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var meow__default = /*#__PURE__*/_interopDefault(meow);
+var esbuild__default = /*#__PURE__*/_interopDefault(esbuild);
+var fse__default = /*#__PURE__*/_interopDefault(fse);
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var path__default = /*#__PURE__*/_interopDefault(path);
+var resolve__default = /*#__PURE__*/_interopDefault(resolve);
+var chalk__default = /*#__PURE__*/_interopDefault(chalk);
+var express__default = /*#__PURE__*/_interopDefault(express$1);
+var next__default = /*#__PURE__*/_interopDefault(next);
+var path__default$1 = /*#__PURE__*/_interopDefault(path$1);
+var prompts__default = /*#__PURE__*/_interopDefault(prompts);
+var https__default = /*#__PURE__*/_interopDefault(https);
+var ci__default = /*#__PURE__*/_interopDefault(ci);
+var Conf__default = /*#__PURE__*/_interopDefault(Conf);
+
+function doesConfigExist(path) {
+  try {
+    const configPath = path__default["default"].join(process.cwd(), ...path);
+    resolve__default["default"].sync(configPath, {
+      extensions: ['.ts', '.tsx', '.js'],
+      preserveSymlinks: false
+    });
+    return true;
+  } catch (err) {
+    if (err.code === 'MODULE_NOT_FOUND') return false;
+    throw err;
+  }
+}
+function appTemplate(config, adminMeta) {
+  const allViews = adminMeta.views.map(viewRelativeToProject => {
+    const isRelativeToFile = viewRelativeToProject.startsWith('./') || viewRelativeToProject.startsWith('../');
+    const viewRelativeToAppFile = isRelativeToFile ? '../../../' + viewRelativeToProject : viewRelativeToProject;
+
+    // we're not using serializePathForImport here because we want the thing you write for a view
+    // to be exactly what you would put in an import in the project directory.
+    // we're still using JSON.stringify to escape anything that might need to be though
+    return JSON.stringify(viewRelativeToAppFile);
+  });
+  // -- TEMPLATE START
+  return `import { getApp } from '@nixxie-cms/core/___internal-do-not-use-will-break-in-patch/admin-ui/pages/App'
+
+${allViews.map((views, i) => `import * as view${i} from ${views}`).join('\n')}
+
+${doesConfigExist(['.nixxie', 'admin', 'config']) ? `import * as packageAdminConfig from "../../../.nixxie/admin/config"` : 'let packageAdminConfig = {}'}
+
+${doesConfigExist(['admin', 'config']) ? `import * as userAdminConfig from "../../../admin/config"` : 'let userAdminConfig = {}'}
+
+export default getApp({
+  adminConfig: {
+    ...packageAdminConfig,
+    ...userAdminConfig
+  },
+  apiPath: "${config.graphql.path}",
+  fieldViews: [${allViews.map((_, i) => `view${i}`)}],
+})
+`;
+}
+
+const createItemTemplate = listKey => `import { getCreateItemPage } from '@nixxie-cms/core/___internal-do-not-use-will-break-in-patch/admin-ui/pages/CreateItemPage';
+
+export default getCreateItemPage(${JSON.stringify({
+  listKey
+})})
+`;
+
+const homeTemplate = `export { HomePage as default } from '@nixxie-cms/core/___internal-do-not-use-will-break-in-patch/admin-ui/pages/HomePage';
+`;
+
+const itemTemplate = listKey => `import { getItemPage } from '@nixxie-cms/core/___internal-do-not-use-will-break-in-patch/admin-ui/pages/ItemPage';
+
+export default getItemPage(${JSON.stringify({
+  listKey
+})})
+`;
+
+const listTemplate = listKey => `import { getListPage } from '@nixxie-cms/core/___internal-do-not-use-will-break-in-patch/admin-ui/pages/ListPage';
+
+export default getListPage(${JSON.stringify({
+  listKey
+})});
+`;
+
+const nextConfigTemplate = basePath => `const nextConfig = {
+    bundlePagesRouterDependencies: true,
+    typescript: {
+      ignoreBuildErrors: true,
+    },
+    eslint: {
+      ignoreDuringBuilds: true,
+    },
+    // We use transpilePackages for the custom admin-ui pages in the ./admin folder
+    // as they import ts files into nextjs
+    transpilePackages: ['../../admin'],
+    ${basePath ? `basePath: '${basePath}',` : ''}
+  }
+
+  module.exports = nextConfig`;
+
+const noAccessTemplate = session => `import { getNoAccessPage } from '@nixxie-cms/core/___internal-do-not-use-will-break-in-patch/admin-ui/pages/NoAccessPage';
+
+export default getNoAccessPage(${JSON.stringify({
+  sessionsEnabled: !!session
+})})
+`;
+
+const pkgDir$1 = path__default["default"].dirname(require.resolve('@nixxie-cms/core/package.json'));
+function writeAdminFiles(config, adminMeta) {
+  var _config$ui;
+  return [{
+    mode: 'write',
+    src: nextConfigTemplate((_config$ui = config.ui) === null || _config$ui === void 0 ? void 0 : _config$ui.basePath),
+    outputPath: 'next.config.js'
+  }, {
+    mode: 'copy',
+    inputPath: path__default["default"].join(pkgDir$1, 'static', 'favicon.ico'),
+    outputPath: 'public/favicon.ico'
+  }, {
+    mode: 'copy',
+    inputPath: path__default["default"].join(pkgDir$1, 'static', 'favicon.svg'),
+    outputPath: 'public/favicon.svg'
+  }, {
+    mode: 'write',
+    src: noAccessTemplate(config.session),
+    outputPath: 'pages/no-access.js'
+  }, {
+    mode: 'write',
+    src: appTemplate(config, adminMeta),
+    outputPath: 'pages/_app.js'
+  }, {
+    mode: 'write',
+    src: homeTemplate,
+    outputPath: 'pages/index.js'
+  }, ...adminMeta.lists.flatMap(({
+    path,
+    key
+  }) => [{
+    mode: 'write',
+    src: listTemplate(key),
+    outputPath: `pages/${path}/index.js`
+  }, {
+    mode: 'write',
+    src: itemTemplate(key),
+    outputPath: `pages/${path}/[id].js`
+  }, {
+    mode: 'write',
+    src: createItemTemplate(key),
+    outputPath: `pages/${path}/create.js`
+  }])];
+}
+
+const walk = node_util.promisify(fs_walk.walk);
+function toPosixPath(p) {
+  return p.split(path__default["default"].sep).join('/');
+}
+function serializePathForImport(path) {
+  // JSON.stringify is important here because it will escape windows style paths(and any thing else that might potentially be in there)
+  return JSON.stringify(toPosixPath(path
+  // Next is unhappy about imports that include .ts/tsx in them because TypeScript is unhappy with them because when doing a TypeScript compilation with tsc, the imports won't be written so they would be wrong there
+  .replace(/\.tsx?$/, '')));
+}
+async function writeAdminFile(file, projectAdminPath) {
+  const outputFilename = path__default["default"].join(projectAdminPath, file.outputPath);
+  if (file.mode === 'copy') {
+    if (!path__default["default"].isAbsolute(file.inputPath)) {
+      throw new Error(`An inputPath of "${file.inputPath}" was provided to copy but inputPaths must be absolute`);
+    }
+    await fse__default["default"].ensureDir(path__default["default"].dirname(outputFilename));
+    // TODO: should we use copyFile or copy?
+    await fs__default["default"].copyFile(file.inputPath, outputFilename);
+  }
+  let content;
+  try {
+    content = await fs__default["default"].readFile(outputFilename, 'utf8');
+  } catch (err) {
+    if (err.code !== 'ENOENT') throw err;
+  }
+  if (file.mode === 'write' && content !== file.src) {
+    await fse__default["default"].outputFile(outputFilename, file.src);
+  }
+  return path__default["default"].normalize(outputFilename);
+}
+const pageExtensions = new Set(['.js', '.jsx', '.ts', '.tsx']);
+async function generateAdminUI(config, adminMeta, projectAdminPath, isLiveReload) {
+  await system.withSpan('generating admin next application', async () => {
+    // when we're not doing a live reload, we want to clear everything out except the .next directory (not the .next directory because it has caches)
+    // so that at least every so often, we'll clear out anything that the deleting we do during live reloads doesn't (should just be directories)
+    if (!isLiveReload) {
+      const dir = await fs__default["default"].readdir(projectAdminPath).catch(err => {
+        if (err.code === 'ENOENT') return [];
+        throw err;
+      });
+      await Promise.all(dir.map(x => {
+        if (x === '.next') return;
+        return fs__default["default"].rm(path__default["default"].join(projectAdminPath, x), {
+          recursive: true
+        });
+      }));
+    }
+
+    // Write out the files configured by the user
+    const userFilesToWrite = await config.ui.getAdditionalFiles();
+    const savedFiles = await Promise.all(userFilesToWrite.map(file => writeAdminFile(file, projectAdminPath)));
+    const uniqueFiles = new Set(savedFiles);
+
+    // Add files to pages/ which point to any files which exist in admin/pages
+    const adminConfigDir = path__default["default"].join(process.cwd(), 'admin');
+    const userPagesDir = path__default["default"].join(adminConfigDir, 'pages');
+    let userPagesEntries = [];
+    try {
+      userPagesEntries = await walk(userPagesDir, {
+        entryFilter: entry => entry.dirent.isFile() && pageExtensions.has(path__default["default"].extname(entry.name))
+      });
+    } catch (err) {
+      if (err.code !== 'ENOENT') throw err;
+    }
+
+    // Collect files into a map keyed by outputPath to handle duplicates
+    // User-provided files take precedence over internal files
+    const adminFilesMap = new Map();
+
+    // Add internal files first
+    for (const file of writeAdminFiles(config, adminMeta)) {
+      adminFilesMap.set(file.outputPath, file);
+    }
+
+    // Add user page files (these override internal files)
+    for (const {
+      path
+    } of userPagesEntries) {
+      const outputFilename = toPosixPath(path__default["default"].relative(adminConfigDir, path));
+      const importPath = path__default["default"].relative(path__default["default"].dirname(path__default["default"].join(projectAdminPath, outputFilename)), path);
+      const serializedImportPath = serializePathForImport(importPath);
+      adminFilesMap.set(outputFilename, {
+        mode: 'write',
+        outputPath: outputFilename,
+        src: `export { default } from ${serializedImportPath}`
+      });
+    }
+
+    // Filter out files already written by getAdditionalFiles() and convert to array
+    const adminFiles = Array.from(adminFilesMap.values()).filter(x => !uniqueFiles.has(path__default["default"].normalize(path__default["default"].join(projectAdminPath, x.outputPath))));
+
+    // Write distinct output paths in parallel after deterministic de-duplication
+    await Promise.all(adminFiles.map(file => writeAdminFile(file, projectAdminPath)));
+
+    // Because Next will re-compile things (or at least check things and log a bunch of stuff)
+    // if we delete pages and then re-create them, we want to avoid that when live reloading
+    // so we only delete things that shouldn't exist anymore
+    // this won't clear out empty directories, this is fine since:
+    // - they won't create pages in Admin UI which is really what this deleting is about avoiding
+    // - we'll remove them when the user restarts the process
+    if (isLiveReload) {
+      const ignoredDir = path__default["default"].resolve(projectAdminPath, '.next');
+      const ignoredFiles = new Set([...adminFiles.map(x => x.outputPath), ...uniqueFiles, 'next-env.d.ts', 'pages/api/__nixxie_api_build.js'].map(x => path__default["default"].resolve(projectAdminPath, x)));
+      const entries = await walk(projectAdminPath, {
+        deepFilter: entry => entry.path !== ignoredDir,
+        entryFilter: entry => entry.dirent.isFile() && !ignoredFiles.has(entry.path)
+      });
+      await Promise.all(entries.map(entry => fs__default["default"].rm(entry.path, {
+        recursive: true
+      })));
+    }
+  });
+}
+
+// WARNING: be careful not to import this file within next
+function identity(x) {
+  return x;
+}
+async function getEsbuildConfigFn(cwd) {
+  try {
+    await esbuild__default["default"].build({
+      entryPoints: ['./esbuild.nixxie'],
+      absWorkingDir: cwd,
+      bundle: true,
+      sourcemap: true,
+      outfile: '.nixxie/esbuild.js',
+      format: 'cjs',
+      platform: 'node',
+      logLevel: 'silent'
+    });
+  } catch (e) {
+    var _e$errors;
+    if (!((_e$errors = e.errors) !== null && _e$errors !== void 0 && _e$errors.some(err => err.text.includes('Could not resolve')))) throw e;
+    return;
+  }
+  try {
+    return require(require.resolve(`${cwd}/.nixxie/esbuild.js`)).default;
+  } catch (err) {
+    if (err.code !== 'MODULE_NOT_FOUND') throw err;
+  }
+}
+async function getEsbuildConfig(cwd) {
+  var _await$getEsbuildConf;
+  const esbuildFn = (_await$getEsbuildConf = await getEsbuildConfigFn(cwd)) !== null && _await$getEsbuildConf !== void 0 ? _await$getEsbuildConf : identity;
+  const resolveDir = path__default["default"].join(cwd, '.nixxie');
+  const importer = path__default["default"].join(cwd, '.nixxie/config.js');
+  // we need the .nixxie directory to exist so when we resolve from it below, it actually exists
+  await fs__default["default"].mkdir(resolveDir, {
+    // while we don't need to actually make this recursive,
+    // this will make mkdir not error when the directory already exists
+    recursive: true
+  });
+  return esbuildFn({
+    entryPoints: ['./nixxie'],
+    absWorkingDir: cwd,
+    bundle: true,
+    sourcemap: true,
+    jsx: 'automatic',
+    // TODO: this cannot be changed for now, circular dependency with getSystemPaths, getEsbuildConfig
+    outfile: '.nixxie/config.js',
+    format: 'cjs',
+    platform: 'node',
+    plugins: [{
+      name: 'external-node_modules',
+      setup(build) {
+        build.onResolve({
+          namespace: 'file',
+          // anything this is a relative path, we know that we definitely want to bundle it
+          // so we can skip running the function
+          //   WARNING: we can't use a negative lookahead/lookbehind because esbuild uses Go
+          filter: /(?:^[^.])|(?:^\.[^/.])|(?:^\.\.[^/])/
+        }, async ({
+          path,
+          ...args
+        }) => {
+          const resolved = await build.resolve(path, {
+            ...args,
+            namespace: 'inner'
+          });
+          if (
+          // we want to bundle everything _except_ node_modules
+          // to avoid problems with duplicate instances of modules
+          // note that this will still bundle monorepo dependencies
+          // since the realpath of the modules will be outside node_modules
+          // even though they're symlinked into node_modules
+          resolved.path.includes('node_modules')) {
+            const resolvedFromOutputMaybeEsm = await build.resolve(path, {
+              resolveDir,
+              importer,
+              kind: 'import-statement',
+              namespace: 'inner'
+            });
+            // if Node will be able to resolve the module using the path written,
+            // we can emit imports that are the same as what was written
+            if (resolved.path === resolvedFromOutputMaybeEsm.path) {
+              return {
+                path,
+                external: true
+              };
+            }
+            // otherwise, we need to use longer relative paths to exactly where the module is
+            // this might involve imports that look like
+            // ../../packages/something/node_modules/something/index.js
+            // which is unfortunate, but not really a significant problem
+            // we also want to resolve it with node:module createRequire
+            // so that we'll get the cjs version
+            const resolvedFromImporterCjs = node_module.createRequire(args.importer).resolve(path);
+            return {
+              path: path__default["default"].relative('.nixxie', resolvedFromImporterCjs),
+              external: true
+            };
+          }
+          if (
+          // this exception is purely here for projects in the nixxie repo itself
+          // since if we bundled @nixxie-cms/core, we would cause problems with the duplicated
+          // when using a published version of nixxie, this should absolutely nothing
+          // since imports to @nixxie-cms/core will be in node_modules
+          path.startsWith('@nixxie-cms/core')) {
+            return {
+              path,
+              external: true
+            };
+          }
+          return resolved;
+        });
+      }
+    }]
+  });
+}
+
+async function build(cwd, {
+  frozen,
+  prisma,
+  quiet,
+  ui
+}) {
+  var _system$config$ui;
+  function log(message) {
+    if (quiet) return;
+    console.log(message);
+  }
+
+  // log('✨ Building Nixxie configuration')
+  await esbuild__default["default"].build(await getEsbuildConfig(cwd));
+  const system$1 = system.createSystem(await express.importBuiltNixxieConfiguration(cwd));
+  if (prisma) {
+    if (frozen) {
+      await express.validateArtifacts(cwd, system$1);
+      log('✨ GraphQL and Prisma schemas are up to date'); // TODO: validating?
+    } else {
+      await express.generateArtifacts(cwd, system$1);
+      log('✨ Generated GraphQL and Prisma schemas'); // TODO: generating?
+    }
+    await express.generateTypes(cwd, system$1);
+    await express.generatePrismaClient(cwd, system$1);
+  }
+  if ((_system$config$ui = system$1.config.ui) !== null && _system$config$ui !== void 0 && _system$config$ui.isDisabled || !ui) return;
+  log('✨ Generating Admin UI code');
+  const paths = system$1.getPaths(cwd);
+  await generateAdminUI(system$1.config, system$1.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;
+  await nextBuild(paths.admin, undefined, undefined, undefined, undefined, undefined, undefined, undefined, 'default', undefined);
+}
+
+const pkgDir = path__default$1["default"].dirname(node_module.createRequire(__dirname).resolve('@nixxie-cms/core/package.json'));
+
+const adminErrorHTMLFilepath = path__default["default"].join(pkgDir, 'static', 'admin-error.html');
+function createAdminUIMiddlewareWithNextApp(config, commonContext, nextApp) {
+  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, res) => {
+    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 === null || pageMiddleware === void 0 ? void 0 : 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.');
+        }
+      });
+    }
+  };
+}
+
+// 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
+
+async function confirmPrompt(message, initial = true) {
+  const {
+    value
+  } = await prompts__default["default"]({
+    name: 'value',
+    type: 'confirm',
+    message,
+    initial
+  });
+  if (value === undefined) {
+    process.exit(1);
+  }
+  return value;
+}
+async function textPrompt(message) {
+  const {
+    value
+  } = await prompts__default["default"]({
+    name: 'value',
+    type: 'text',
+    message
+  });
+  if (value === undefined) {
+    process.exit(1);
+  }
+  return value;
+}
+
+const defaultTelemetryEndpoint = 'https://telemetry.nixxiecms.com/3/';
+function log(message) {
+  if (process.env.KEYSTONE_TELEMETRY_DEBUG === '1') {
+    console.log(`${message}`);
+  }
+}
+function getTelemetryConfig() {
+  const userConfig = new Conf__default["default"]({
+    projectName: 'nixxiecms',
+    projectSuffix: '',
+    projectVersion: '3.0.0',
+    migrations: {
+      '^2.0.0': store => {
+        var _existing$device$last;
+        const existing = store.get('telemetry');
+        if (!existing) return; // skip non-configured or known opt-outs
+
+        const replacement = {
+          informedAt: null,
+          // re-inform
+          device: {
+            lastSentDate: (_existing$device$last = existing.device.lastSentDate) !== null && _existing$device$last !== void 0 ? _existing$device$last : null
+          },
+          projects: {} // see below
+        };
+
+        // copy existing project.lastSentDate's
+        for (const [projectPath, project] of Object.entries(existing.projects)) {
+          if (projectPath === 'default') continue; // informedAt moved to device.lastSentDate
+
+          // dont copy garbage
+          if (typeof project !== 'object') continue;
+          if (typeof project.lastSentDate !== 'string') continue;
+          if (new Date(project.lastSentDate).toString() === 'Invalid Date') continue;
+
+          // retain lastSentDate
+          replacement.projects[projectPath] = {
+            lastSentDate: project.lastSentDate
+          };
+        }
+        store.set('telemetry', replacement);
+      },
+      '^3.0.0': store => {
+        const existing = store.get('telemetry');
+        if (!existing) return; // skip non-configured or known opt-outs
+
+        store.set('telemetry', {
+          ...existing,
+          informedAt: null // re-inform
+        });
+      }
+    }
+  });
+  return {
+    telemetry: userConfig.get('telemetry'),
+    userConfig
+  };
+}
+function getDefault(telemetry) {
+  if (telemetry) return telemetry;
+  return {
+    informedAt: null,
+    device: {
+      lastSentDate: null
+    },
+    projects: {}
+  }; // help Typescript infer the type
+}
+const todaysDate = new Date().toISOString().slice(0, 10);
+function collectFieldCount(lists) {
+  const fields = {
+    unknown: 0
+  };
+  for (const list of Object.values(lists)) {
+    for (const [fieldPath, field] of Object.entries(list.fields)) {
+      const fieldType = field.__ksTelemetryFieldTypeName;
+      if (!fieldType) {
+        // skip id fields
+        if (fieldPath.endsWith('id')) continue;
+        fields.unknown++;
+        continue;
+      }
+      fields[fieldType] || (fields[fieldType] = 0);
+      fields[fieldType] += 1;
+    }
+  }
+  return fields;
+}
+async function collectPackageVersions() {
+  const packages = {
+    '@nixxie-cms/core': '0.0.0' // "unknown"
+  };
+  for (const packageName of ['@nixxie-cms/core', '@nixxie-cms/auth', '@nixxie-cms/fields-document', '@nixxie-cms/cloudinary', '@nixxie-cms/session-store-redis',
+  // we hope usage to drops to zero
+  '@opensaas/nixxie-nextjs-auth']) {
+    try {
+      const packageJson = require(`${packageName}/package.json`);
+      // const packageJson = await import(`${packageName}/package.json`, { assert: { type: 'json' } }) // TODO: broken in jest
+      packages[packageName] = packageJson.version;
+    } catch (err) {
+      // do nothing, the package is probably not installed
+    }
+  }
+  return packages;
+}
+function printNext(telemetry) {
+  if (!telemetry) {
+    console.log(`Telemetry data will ${chalk.red`not`} be sent by this system user`);
+    return;
+  }
+  console.log(`Telemetry data will be sent the next time you run ${chalk.green`"nixxie dev"`}`);
+}
+function printTelemetryStatus(telemetry, updated = false) {
+  const auxverb = updated ? 'has been' : 'is';
+  if (telemetry === undefined) {
+    console.log(`Nixxie telemetry ${auxverb} ${chalk.yellow`uninitialized`}`);
+    console.log();
+    printNext(telemetry);
+    return;
+  }
+  if (telemetry === false) {
+    console.log(`Nixxie telemetry ${auxverb} ${chalk.red`disabled`}`);
+    console.log();
+    printNext(telemetry);
+    return;
+  }
+  console.log(`Nixxie telemetry ${auxverb} ${chalk.green`enabled`}`);
+  console.log();
+  console.log(`  Device telemetry was last sent on ${telemetry.device.lastSentDate}`);
+  for (const [projectPath, project] of Object.entries(telemetry.projects)) {
+    console.log(`  Project telemetry for "${chalk.yellow(projectPath)}" was last sent on ${project === null || project === void 0 ? void 0 : project.lastSentDate}`);
+  }
+  console.log();
+  printNext(telemetry);
+}
+function inform(telemetry, userConfig) {
+  console.log(); // gap to help visiblity
+  console.log(`${chalk.bold('Nixxie Telemetry')}`);
+  console.log(`${chalk.yellow`Nixxie collects anonymous data when you run`} ${chalk.green`"nixxie dev"`}`);
+  console.log(`You can use ${chalk.green`"nixxie telemetry --help"`} to update your preferences at any time`);
+  if (telemetry.informedAt === null) {
+    console.log();
+    console.log(`No telemetry data has been sent as part of this notice`);
+  }
+  console.log();
+  printNext(telemetry);
+  console.log(); // gap to help visiblity
+  console.log(`For more information, including how to opt-out see ${chalk.grey`https://nixxiecms.com/telemetry`} (updated ${chalk.blue`2024-08-20`})`);
+
+  // update the informedAt
+  telemetry.informedAt = new Date().toJSON();
+  userConfig.set('telemetry', telemetry);
+}
+async function sendEvent(eventType, eventData) {
+  const endpoint = process.env.KEYSTONE_TELEMETRY_ENDPOINT || defaultTelemetryEndpoint;
+  await new Promise(resolve => {
+    const req = https__default["default"].request(`${endpoint}${eventType}`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    }, () => resolve());
+    req.once('error', err => {
+      var _err$message;
+      log((_err$message = err === null || err === void 0 ? void 0 : err.message) !== null && _err$message !== void 0 ? _err$message : err);
+      resolve();
+    });
+    req.end(JSON.stringify(eventData));
+  });
+  log(`sent ${eventType} report`);
+}
+async function sendProjectTelemetryEvent(cwd, lists, dbProviderName, telemetry, userConfig) {
+  var _telemetry$projects$c;
+  const project = (_telemetry$projects$c = telemetry.projects[cwd]) !== null && _telemetry$projects$c !== void 0 ? _telemetry$projects$c : {
+    lastSentDate: null
+  };
+  const {
+    lastSentDate
+  } = project;
+  if (lastSentDate && lastSentDate === todaysDate) {
+    log('project telemetry already sent today');
+    return;
+  }
+  await sendEvent('project', {
+    lastSentDate,
+    packages: await collectPackageVersions(),
+    database: dbProviderName,
+    lists: Object.keys(lists).length,
+    fields: collectFieldCount(lists)
+  });
+
+  // update the project lastSentDate
+  telemetry.projects[cwd] = {
+    lastSentDate: todaysDate
+  };
+  userConfig.set('telemetry', telemetry);
+}
+async function sendDeviceTelemetryEvent(telemetry, userConfig) {
+  const {
+    lastSentDate
+  } = telemetry.device;
+  if (lastSentDate && lastSentDate === todaysDate) {
+    log('device telemetry already sent today');
+    return;
+  }
+  await sendEvent('device', {
+    lastSentDate,
+    os: node_os.platform(),
+    node: process.versions.node.split('.')[0]
+  });
+
+  // update the device lastSentDate
+  telemetry.device = {
+    lastSentDate: todaysDate
+  };
+  userConfig.set('telemetry', telemetry);
+}
+async function runTelemetry(cwd, lists, dbProviderName) {
+  try {
+    if (ci__default["default"].isCI) {
+      console.log(`Nixxie Telemetry is ${chalk.red`disabled`} (running in CI)`);
+      return;
+    }
+    const {
+      telemetry,
+      userConfig
+    } = getTelemetryConfig();
+    if (telemetry === false) {
+      console.log(`Nixxie Telemetry is ${chalk.red`disabled`} (via opt-out)`);
+      return;
+    }
+    if (process.env.NIXXIE_TELEMETRY_DISABLED === '1') {
+      console.log(`Nixxie Telemetry is ${chalk.red`disabled`} (NIXXIE_TELEMETRY_DISABLED is set)`);
+      return;
+    }
+    if (process.env.DO_NOT_TRACK === '1') {
+      console.log(`Nixxie Telemetry is ${chalk.red`disabled`} (DO_NOT_TRACK is set)`);
+      return;
+    }
+    if (process.env.NODE_ENV === 'production') {
+      console.log(`Nixxie Telemetry is ${chalk.red`disabled`} (NODE_ENV is production)`);
+      return;
+    }
+
+    // don't send telemetry before we inform the user, allowing opt-out
+    const telemetryDefaulted = getDefault(telemetry);
+    if (!telemetryDefaulted.informedAt) return inform(telemetryDefaulted, userConfig);
+    console.log(`Nixxie Telemetry is ${chalk.green`enabled`}`);
+    await sendProjectTelemetryEvent(cwd, lists, dbProviderName, telemetryDefaulted, userConfig);
+    await sendDeviceTelemetryEvent(telemetryDefaulted, userConfig);
+  } catch (err) {
+    var _err$message2;
+    log((_err$message2 = err === null || err === void 0 ? void 0 : err.message) !== null && _err$message2 !== void 0 ? _err$message2 : err);
+  }
+}
+function statusTelemetry(updated = false) {
+  const {
+    telemetry
+  } = getTelemetryConfig();
+  printTelemetryStatus(telemetry, updated);
+}
+function informTelemetry() {
+  const {
+    userConfig
+  } = getTelemetryConfig();
+  inform(getDefault(false), userConfig);
+}
+function enableTelemetry() {
+  const {
+    telemetry,
+    userConfig
+  } = getTelemetryConfig();
+  if (!telemetry) {
+    userConfig.set('telemetry', getDefault(telemetry));
+  }
+  statusTelemetry(true);
+}
+function disableTelemetry() {
+  const {
+    userConfig
+  } = getTelemetryConfig();
+  userConfig.set('telemetry', false);
+  statusTelemetry(true);
+}
+function resetTelemetry() {
+  const {
+    userConfig
+  } = getTelemetryConfig();
+  userConfig.delete('telemetry');
+  statusTelemetry(true);
+}
+
+async function noop() {}
+const devLoadingHTMLFilepath = path__default["default"].join(pkgDir, 'static', 'dev-loading.html');
+function stripExtendHttpServer(config) {
+  const {
+    server,
+    ...rest
+  } = config;
+  const {
+    extendHttpServer,
+    ...restServer
+  } = server;
+  return {
+    ...rest,
+    server: {
+      ...restServer,
+      extendHttpServer: noop
+    }
+  };
+}
+function resolvablePromise() {
+  let _resolve;
+  const promise = new Promise(resolve => {
+    _resolve = resolve;
+  });
+  promise.resolve = _resolve;
+  return promise;
+}
+async function dev(cwd, {
+  dbPush,
+  prisma,
+  quiet,
+  server,
+  ui
+}) {
+  var _esbuildConfig$plugin;
+  function log(message) {
+    if (quiet) return;
+    console.log(message);
+  }
+  log('✨ Starting Nixxie');
+  let lastPromise = resolvablePromise();
+  const builds = {
+    [Symbol.asyncIterator]: () => ({
+      next: () => lastPromise
+    })
+  };
+  function addBuildResult(build) {
+    const prev = lastPromise;
+    lastPromise = resolvablePromise();
+    prev.resolve({
+      value: build,
+      done: false
+    });
+  }
+  const esbuildConfig = await getEsbuildConfig(cwd);
+  const esbuildContext = await esbuild__default["default"].context({
+    ...esbuildConfig,
+    plugins: [...((_esbuildConfig$plugin = esbuildConfig.plugins) !== null && _esbuildConfig$plugin !== void 0 ? _esbuildConfig$plugin : []), {
+      name: 'esbuildWatchPlugin',
+      setup(build) {
+        // TODO: no any
+        build.onEnd(addBuildResult);
+      }
+    }]
+  });
+  try {
+    const firstBuild = await esbuildContext.rebuild();
+    addBuildResult(firstBuild);
+  } catch (e) {
+    // esbuild prints everything we want users to see
+  }
+  esbuildContext.watch();
+  let prismaClient = null;
+  async function stop(aHttpServer, exitMessage = '') {
+    await esbuildContext.dispose();
+
+    //   WARNING: this is only actually required for tests
+    // stop httpServer
+    if (aHttpServer) {
+      await new Promise((resolve, reject) => {
+        aHttpServer.close(async err => {
+          if (err) {
+            console.error('Error closing the server', err);
+            return reject(err);
+          }
+          resolve(null);
+        });
+      });
+    }
+
+    //   WARNING: this is only required for tests
+    // stop Prisma
+    try {
+      var _prismaClient, _prismaClient$disconn;
+      await ((_prismaClient = prismaClient) === null || _prismaClient === void 0 || (_prismaClient$disconn = _prismaClient.disconnect) === null || _prismaClient$disconn === void 0 ? void 0 : _prismaClient$disconn.call(_prismaClient));
+    } catch (err) {
+      console.error('Error disconnecting from the database', err);
+      throw err;
+    }
+    if (exitMessage) throw new express.ExitError(1, exitMessage);
+  }
+  const app = server ? express__default["default"]() : null;
+  const httpServer = app ? node_http.createServer(app) : null;
+  let expressServer = null;
+  let hasAddedAdminUIMiddleware = false;
+  const isReady = () => !server || expressServer !== null && hasAddedAdminUIMiddleware;
+  const initNixxie = async () => {
+    var _configWithExtendHttp, _system$config$ui;
+    const configWithExtendHttp = await express.importBuiltNixxieConfiguration(cwd);
+    const {
+      system: system$1,
+      context,
+      prismaClientModule,
+      apolloServer,
+      ...rest
+    } = await async function () {
+      const system$1 = system.createSystem(stripExtendHttpServer(configWithExtendHttp));
+
+      // Generate the Artifacts
+      if (prisma) {
+        log('✨ Generating GraphQL and Prisma schemas');
+        const {
+          prisma: generatedPrismaSchema
+        } = await express.generateArtifacts(cwd, system$1);
+        await express.generateTypes(cwd, system$1);
+        await express.generatePrismaClient(cwd, system$1);
+        const paths = system$1.getPaths(cwd);
+        if (dbPush) {
+          const created = await internals.createDatabase(system$1.config.db.url, path__default["default"].dirname(paths.schema.prisma));
+          if (created) log(`✨ Database created`);
+          const migration = await migrations.withMigrate(paths.schema.prisma, system$1, async m => {
+            // what does force on migrate.engine.schemaPush mean?
+            // - true: ignore warnings, but unexecutable steps will block
+            // - false: warnings or unexecutable steps will block
+            const migration_ = await m.schema(generatedPrismaSchema, false);
+
+            // if there are unexecutable steps, we need to reset the database [or the user can use migrations]
+            if (migration_.unexecutable.length) {
+              console.error(`${chalk__default["default"].bold.red('\n⚠️ We found changes that cannot be executed:\n')}`);
+              for (const item of migration_.unexecutable) {
+                console.error(`  • ${item}`);
+              }
+              if (migration_.warnings.length) {
+                console.error(chalk__default["default"].bold(`\n⚠️  Warnings:\n`));
+                for (const warning of migration_.warnings) {
+                  console.error(`  • ${warning}`);
+                }
+              }
+              console.error('\nTo apply this migration, we need to reset the database');
+              if (!(await confirmPrompt(`Do you want to continue? ${chalk__default["default"].red('The database will be reset')}`, false))) {
+                throw new express.ExitError(1, 'Database reset cancelled by user');
+              }
+              await m.reset();
+              return m.schema(generatedPrismaSchema, false);
+            }
+            if (migration_.warnings.length) {
+              if (migration_.warnings.length) {
+                console.error(chalk__default["default"].bold(`\n⚠️  Warnings:\n`));
+                for (const warning of migration_.warnings) {
+                  console.error(`  • ${warning}`);
+                }
+              }
+              if (!(await confirmPrompt(`Do you want to continue? ${chalk__default["default"].red('Some data will be lost')}`, false))) {
+                throw new express.ExitError(1, 'Database push cancelled by user');
+              }
+              return m.schema(generatedPrismaSchema, true);
+            }
+            return migration_;
+          });
+          if (migration.warnings.length === 0 && migration.executedSteps === 0) {
+            log(`✨ Database unchanged`);
+          } else {
+            log(`✨ Database synchronized with Prisma schema`);
+          }
+        } else {
+          log('⚠️ Skipping database schema push');
+        }
+        const prismaClientModule = require(paths.prisma);
+        const nixxie = system$1.getNixxie(prismaClientModule);
+        log('✨ Connecting to the database');
+        await nixxie.connect(); // TODO: remove, replace with server.onStart
+        if (!server) {
+          return {
+            system: system$1,
+            context: nixxie.context,
+            prismaClientModule
+          };
+        }
+        log('✨ Creating server');
+        const {
+          apolloServer,
+          expressServer
+        } = await express.createExpressServer(system$1.config, nixxie.context);
+        log(`✅ GraphQL API ready`);
+        return {
+          system: system$1,
+          context: nixxie.context,
+          expressServer,
+          apolloServer,
+          prismaClientModule
+        };
+      }
+      return {
+        system: system$1
+      };
+    }();
+    if (configWithExtendHttp !== null && configWithExtendHttp !== void 0 && (_configWithExtendHttp = configWithExtendHttp.server) !== null && _configWithExtendHttp !== void 0 && _configWithExtendHttp.extendHttpServer && httpServer && context) {
+      configWithExtendHttp.server.extendHttpServer(httpServer, context);
+    }
+    prismaClient = context === null || context === void 0 ? void 0 : context.prisma;
+    if (rest.expressServer) {
+      ({
+        expressServer
+      } = rest);
+    }
+    let nextApp;
+    if (!((_system$config$ui = system$1.config.ui) !== null && _system$config$ui !== void 0 && _system$config$ui.isDisabled) && ui) {
+      if (!expressServer || !context) throw new TypeError('Error trying to prepare the Admin UI');
+      log('✨ Generating Admin UI code');
+      const paths = system$1.getPaths(cwd);
+      await fs__default["default"].rm(paths.admin, {
+        recursive: true,
+        force: true
+      });
+      await generateAdminUI(system$1.config, system$1.adminMeta, paths.admin, false);
+      log('✨ Preparing Admin UI');
+      nextApp = next__default["default"]({
+        dev: true,
+        dir: paths.admin
+      });
+      await nextApp.prepare();
+      expressServer.use(createAdminUIMiddlewareWithNextApp(system$1.config, context, nextApp));
+      log(`✅ Admin UI ready`);
+    }
+    hasAddedAdminUIMiddleware = true;
+    initNixxiePromiseResolve();
+    const originalPrismaSchema = express.printPrismaSchema(system$1.config, system$1.lists);
+    let lastPrintedGraphQLSchema = graphql.printSchema(system$1.graphql.schemas.public);
+    let lastApolloServer = apolloServer !== null && apolloServer !== void 0 ? apolloServer : null;
+    if (system$1.config.telemetry !== false) {
+      runTelemetry(cwd, system$1.lists, system$1.config.db.provider);
+    }
+    for await (const buildResult of builds) {
+      if (buildResult.errors.length) continue;
+      log('compiled successfully');
+      try {
+        const paths = system$1.getPaths(cwd);
+
+        // wipe the require cache
+        {
+          const resolved = require.resolve(paths.config);
+          delete require.cache[resolved];
+        }
+        const newConfigWithHttp = await express.importBuiltNixxieConfiguration(cwd);
+        const newSystem = system.createSystem(stripExtendHttpServer(newConfigWithHttp));
+        if (prisma) {
+          if (!originalPrismaSchema) throw new TypeError('Missing Prisma schema source');
+          const newPrismaSchema = express.printPrismaSchema(newSystem.config, newSystem.lists);
+          if (originalPrismaSchema !== newPrismaSchema) {
+            return stop(null, '🔄 Your prisma schema has changed, please restart Nixxie');
+          }
+          // we only need to test for the things which influence the prisma client creation
+          // and aren't written into the prisma schema since we check whether the prisma schema has changed above
+          if (JSON.stringify(newSystem.config.db.enableLogging) !== JSON.stringify(system$1.config.db.enableLogging) || newSystem.config.db.url !== system$1.config.db.url) {
+            return stop(null, 'Your database configuration has changed, please restart Nixxie');
+          }
+        }
+
+        // we're not using generateCommittedArtifacts or any of the similar functions
+        // because we will never need to write a new prisma schema here
+        // and formatting the prisma schema leaves some listeners on the process
+        // which means you get a "there's probably a memory leak" warning from node
+        const newPrintedGraphQLSchema = graphql.printSchema(newSystem.graphql.schemas.public);
+        if (newPrintedGraphQLSchema !== lastPrintedGraphQLSchema) {
+          await fs__default["default"].writeFile(paths.schema.graphql, express.getFormattedGraphQLSchema(newPrintedGraphQLSchema));
+          lastPrintedGraphQLSchema = newPrintedGraphQLSchema;
+        }
+        await express.generateTypes(cwd, newSystem);
+        await generateAdminUI(newSystem.config, newSystem.adminMeta, paths.admin, true);
+        if (prismaClientModule) {
+          if (server && lastApolloServer) {
+            const {
+              context: newContext
+            } = newSystem.getNixxie(prismaClientModule);
+            const servers = await express.createExpressServer(newSystem.config, newContext);
+            if (nextApp) {
+              servers.expressServer.use(createAdminUIMiddlewareWithNextApp(newSystem.config, newContext, nextApp));
+            }
+            expressServer = servers.expressServer;
+            const prevApolloServer = lastApolloServer;
+            lastApolloServer = servers.apolloServer;
+            await prevApolloServer.stop();
+          }
+        }
+      } catch (err) {
+        console.error(`Error loading your Nixxie config`, err);
+      }
+    }
+  };
+
+  // Serve the dev status page for the Admin UI
+  let initNixxiePromiseResolve;
+  let initNixxiePromiseReject;
+  const initNixxiePromise = new Promise((resolve, reject) => {
+    initNixxiePromiseResolve = resolve;
+    initNixxiePromiseReject = reject;
+  });
+  if (app && httpServer) {
+    var _config$server;
+    const config = await express.importBuiltNixxieConfiguration(cwd);
+    app.use('/__nixxie/dev/status', (req, res) => {
+      res.status(isReady() ? 200 : 501).end();
+    });
+    app.use((req, res, next) => {
+      var _config$graphql$path, _config$graphql;
+      if (expressServer && hasAddedAdminUIMiddleware) {
+        return expressServer(req, res, next);
+      }
+      const {
+        pathname
+      } = new URL(req.url, 'http://ks');
+      if (expressServer && pathname === ((_config$graphql$path = (_config$graphql = config.graphql) === null || _config$graphql === void 0 ? void 0 : _config$graphql.path) !== null && _config$graphql$path !== void 0 ? _config$graphql$path : '/api/graphql')) {
+        return expressServer(req, res, next);
+      }
+      res.sendFile(devLoadingHTMLFilepath);
+    });
+    const httpOptions = {
+      port: 3000
+    };
+    if (config !== null && config !== void 0 && config.server && 'port' in config.server && typeof ((_config$server = config.server) === null || _config$server === void 0 ? void 0 : _config$server.port) === 'number') {
+      httpOptions.port = config.server.port;
+    }
+    if (config !== null && config !== void 0 && config.server && 'options' in config.server && config.server.options) {
+      Object.assign(httpOptions, config.server.options);
+    }
+
+    // preference env.PORT if supplied
+    if ('PORT' in process.env) {
+      var _process$env$PORT;
+      httpOptions.port = parseInt((_process$env$PORT = process.env.PORT) !== null && _process$env$PORT !== void 0 ? _process$env$PORT : '');
+    }
+
+    // preference env.HOST if supplied
+    if ('HOST' in process.env) {
+      var _process$env$HOST;
+      httpOptions.host = (_process$env$HOST = process.env.HOST) !== null && _process$env$HOST !== void 0 ? _process$env$HOST : '';
+    }
+    const server = httpServer.listen(httpOptions, err => {
+      var _httpOptions$host, _config$graphql$path2, _config$graphql2;
+      if (err) throw err;
+      const easyHost = [undefined, '', '::', '0.0.0.0'].includes(httpOptions.host) ? 'localhost' : httpOptions.host;
+      log(`⭐️ Server listening on ${(_httpOptions$host = httpOptions.host) !== null && _httpOptions$host !== void 0 ? _httpOptions$host : ''}:${httpOptions.port} (http://${easyHost}:${httpOptions.port}/)`);
+      log(`⭐️ GraphQL API available at ${(_config$graphql$path2 = (_config$graphql2 = config.graphql) === null || _config$graphql2 === void 0 ? void 0 : _config$graphql2.path) !== null && _config$graphql$path2 !== void 0 ? _config$graphql$path2 : '/api/graphql'}`);
+
+      // Don't start initialising Nixxie until the dev server is ready,
+      // otherwise it slows down the first response significantly
+      initNixxie().catch(async err => {
+        await stop(server);
+        initNixxiePromiseReject(err);
+      });
+    });
+    await initNixxiePromise;
+    return async () => await stop(server);
+  } else {
+    await initNixxie();
+    return () => Promise.resolve();
+  }
+}
+
+async function spawnPrisma(cwd, system, commands) {
+  let output = '';
+  return new Promise((resolve, reject) => {
+    const p = node_child_process.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
+    }));
+  });
+}
+async function migrateCreate(cwd, {
+  frozen,
+  quiet
+}) {
+  function log(message) {
+    if (quiet) return;
+    console.log(message);
+  }
+  await esbuild__default["default"].build(await getEsbuildConfig(cwd));
+  const system$1 = system.createSystem(await express.importBuiltNixxieConfiguration(cwd));
+  if (frozen) {
+    await express.validateArtifacts(cwd, system$1);
+    log('✨ GraphQL and Prisma schemas are up to date');
+  } else {
+    await express.generateArtifacts(cwd, system$1);
+    log('✨ Generated GraphQL and Prisma schemas');
+  }
+  await express.generateTypes(cwd, system$1);
+  await express.generatePrismaClient(cwd, system$1);
+
+  // TODO: remove, should be Prisma
+  await fse__default["default"].outputFile(path.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$1.config.db.provider}`);
+  // TODO: remove, should be Prisma
+  let deleteShadowDatabase = async () => {};
+  let shadowDatabaseUrl = system$1.config.db.shadowDatabaseUrl;
+  if (system$1.config.db.provider !== 'sqlite' && !shadowDatabaseUrl) {
+    const parsedUrl = new URL(system$1.config.db.url);
+    parsedUrl.pathname = `ktmp${Date.now()}_${node_crypto.randomBytes(6).toString('hex')}`;
+    shadowDatabaseUrl = parsedUrl.toString();
+    try {
+      await internals.createDatabase(shadowDatabaseUrl);
+    } catch (err) {
+      console.error(err);
+      console.error(chalk__default["default"].red('Failed to create shadow database, db.shadowDatabaseUrl may be required'));
+      throw new express.ExitError(1);
+    }
+    deleteShadowDatabase = async () => {
+      await internals.dropDatabase(shadowDatabaseUrl);
+    };
+  }
+  let sql;
+  try {
+    const paths = system$1.getPaths(cwd);
+    const {
+      output: summary,
+      exitCode: prismaExitCode
+    } = await spawnPrisma(cwd, system$1, ['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 express.ExitError(prismaExitCode);
+    }
+    if (summary.startsWith('No difference detected')) {
+      log('🔄 Database unchanged from Prisma schema');
+      throw new express.ExitError(0);
+    }
+    console.error(summary);
+    const {
+      output,
+      exitCode: prismaExitCode2
+    } = await spawnPrisma(cwd, system$1, ['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 express.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$1 = path.join(`migrations`, `${prefix}_${name}/migration.sql`);
+  await fse__default["default"].outputFile(path.join(cwd, path$1), sql);
+  log(`✨ Generated SQL migration at ${path$1}`);
+}
+async function migrateApply(cwd, {
+  frozen,
+  quiet
+}) {
+  function log(message) {
+    if (quiet) return;
+    console.log(message);
+  }
+
+  // TODO: should this happen if frozen?
+  await esbuild__default["default"].build(await getEsbuildConfig(cwd));
+  const system$1 = system.createSystem(await express.importBuiltNixxieConfiguration(cwd));
+  if (frozen) {
+    await express.validateArtifacts(cwd, system$1);
+    log('✨ GraphQL and Prisma schemas are up to date');
+  } else {
+    await express.generateArtifacts(cwd, system$1);
+    log('✨ Generated GraphQL and Prisma schemas');
+  }
+  await express.generateTypes(cwd, system$1);
+  await express.generatePrismaClient(cwd, system$1);
+  log('✨ Applying any database migrations');
+  const paths = system$1.getPaths(cwd);
+  const {
+    appliedMigrationNames
+  } = await migrations.withMigrate(paths.schema.prisma, system$1, 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__default["default"].red('The database will be reset')}`);
+      if (!consent) throw new express.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`);
+}
+
+async function spawnPrisma3(cwd, system, commands) {
+  return new Promise((resolve, reject) => {
+    const p = node_child_process.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
+    }));
+  });
+}
+async function prisma(cwd, args, frozen) {
+  // TODO: should build unless --frozen?
+
+  const system$1 = system.createSystem(await express.importBuiltNixxieConfiguration(cwd));
+  await express.validateArtifacts(cwd, system$1);
+  const {
+    exitCode
+  } = await spawnPrisma3(cwd, system$1, args);
+  if (typeof exitCode === 'number' && exitCode !== 0) {
+    throw new express.ExitError(exitCode);
+  }
+}
+
+async function start(cwd, {
+  quiet,
+  server,
+  ui,
+  withMigrations
+}) {
+  var _system$config$ui;
+  function log(message) {
+    if (quiet) return;
+    console.log(message);
+  }
+  log('✨ Starting Nixxie');
+  const system$1 = system.createSystem(await express.importBuiltNixxieConfiguration(cwd));
+  const paths = system$1.getPaths(cwd);
+  if (withMigrations) {
+    log('✨ Applying any database migrations');
+    const {
+      appliedMigrationNames
+    } = await migrations.withMigrate(paths.schema.prisma, system$1, 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$1.getNixxie(prismaClient);
+  log('✨ Connecting to the database');
+  await nixxie.connect();
+  log('✨ Creating server');
+  const {
+    expressServer,
+    httpServer
+  } = await express.createExpressServer(system$1.config, nixxie.context);
+  log(`✅ GraphQL API ready`);
+  if (!((_system$config$ui = system$1.config.ui) !== null && _system$config$ui !== void 0 && _system$config$ui.isDisabled) && ui) {
+    log('✨ Preparing Admin UI');
+    const nextApp = next__default["default"]({
+      dev: false,
+      dir: paths.admin
+    });
+    await nextApp.prepare();
+    expressServer.use(createAdminUIMiddlewareWithNextApp(system$1.config, nixxie.context, nextApp));
+    log(`✅ Admin UI ready`);
+  }
+  const httpOptions = system$1.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$1.config.server.options, err => {
+    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}/)`);
+  });
+}
+
+async function telemetry(_, command) {
+  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(`${chalk.bold('Nixxie Telemetry')}`);
+    console.error(usageText);
+    return;
+  }
+  console.error(command ? `Invalid option: ${command}` : '');
+  console.error(usageText);
+}
+
+function defaultFlags(flags, defaults) {
+  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];
+    // should we default the flag?
+    if (value === undefined) {
+      flags[key] = defaultValue;
+    }
+    if (typeof value !== typeof defaultValue) {
+      throw new Error(`Option '${key}' should be of type ${typeof defaultValue}`);
+    }
+  }
+  return flags;
+}
+async function cli(cwd, argv) {
+  const {
+    input,
+    help,
+    flags
+  } = meow__default["default"](`
+    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 express.ExitError(1);
+}
+
+exports.cli = cli;