@nixxie-cms/core 1.0.0

package/dist/express-6743b918.esm.js

@@ -0,0 +1,476 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { formatSchema, getGenerators } from '@prisma/internals';
+import { defaultRegistry } from '@prisma/client-generator-registry';
+import { GraphQLInputObjectType, GraphQLEnumType, introspectionTypes, GraphQLNonNull, GraphQLList, GraphQLScalarType, printSchema, GraphQLError } from 'graphql';
+import { g as getDBFieldKeyForFieldOnMultiField, a as areArraysEqual } from './utils-f9556354.esm.js';
+import { w as withSpan, a as getBuiltNixxieConfigurationPath } from './system-dfec2f0a.esm.js';
+import { createServer } from 'http';
+import cors from 'cors';
+import { json } from 'body-parser';
+import { expressMiddleware } from '@apollo/server/express4';
+import express from 'express';
+import { ApolloServer } from '@apollo/server';
+import { ApolloServerPluginLandingPageDisabled } from '@apollo/server/plugin/disabled';
+import { ApolloServerPluginLandingPageLocalDefault } from '@apollo/server/plugin/landingPage/default';
+import graphqlUploadExpress from 'graphql-upload/graphqlUploadExpress.js';
+
+const modifiers = {
+  required: '',
+  optional: '?',
+  many: '[]'
+};
+function printIndex(fieldPath, index) {
+  return {
+    none: '',
+    unique: '@unique',
+    index: `\n@@index([${fieldPath}])`
+  }[index !== null && index !== void 0 ? index : 'none'];
+}
+function printNativeType(nativeType, datasourceName) {
+  return nativeType === undefined ? '' : ` @${datasourceName}.${nativeType}`;
+}
+function printScalarDefaultValue(defaultValue) {
+  if (defaultValue.kind === 'literal') {
+    if (defaultValue instanceof Uint8Array) {
+      // can't find documentation for it but it seems the expected format for Bytes defaults in Prisma is base64
+      // https://github.com/prisma/prisma-engines/blob/11f45a26bee8dc9c91606fc5130d1025a6e22197/psl/psl-core/src/validate/validation_pipeline/validations/default_value.rs#L77
+      return ` @default("${Buffer.from(defaultValue).toString('base64')}")`;
+    }
+    if (typeof defaultValue.value === 'string') {
+      return ` @default(${JSON.stringify(defaultValue.value)})`;
+    }
+    return ` @default(${defaultValue.value.toString()})`;
+  }
+  if (defaultValue.kind === 'cuid' || defaultValue.kind === 'uuid') {
+    var _defaultValue$version;
+    return ` @default(${defaultValue.kind}(${(_defaultValue$version = defaultValue.version) !== null && _defaultValue$version !== void 0 ? _defaultValue$version : ''}))`;
+  }
+  if (defaultValue.kind === 'nanoid') {
+    var _defaultValue$length;
+    return ` @default(nanoid(${(_defaultValue$length = defaultValue.length) !== null && _defaultValue$length !== void 0 ? _defaultValue$length : ''}))`;
+  }
+  if (defaultValue.kind === 'now' || defaultValue.kind === 'autoincrement' || defaultValue.kind === 'ulid') {
+    return ` @default(${defaultValue.kind}())`;
+  }
+  if (defaultValue.kind === 'dbgenerated') {
+    return ` @default(dbgenerated(${JSON.stringify(defaultValue.value)}))`;
+  }
+  if (defaultValue.kind === 'random') {
+    return '';
+  }
+  assertNever(defaultValue);
+}
+function assertNever(arg) {
+  throw new Error(`expected to never be called but was called with ${arg}`);
+}
+function printField(fieldPath, field, datasourceName, lists) {
+  if (field.kind === 'scalar') {
+    const nativeType = printNativeType(field.nativeType, datasourceName);
+    const index = printIndex(fieldPath, field.index);
+    const defaultValue = field.default ? printScalarDefaultValue(field.default) : '';
+    const map = field.map ? ` @map(${JSON.stringify(field.map)})` : '';
+    const updatedAt = field.updatedAt ? ' @updatedAt' : '';
+    return `${fieldPath} ${field.scalar}${modifiers[field.mode]}${updatedAt}${nativeType}${defaultValue}${map}${index}`;
+  }
+  if (field.kind === 'enum') {
+    const index = printIndex(fieldPath, field.index);
+    const defaultValue = field.default ? ` @default(${field.default.value})` : '';
+    const map = field.map ? ` @map(${JSON.stringify(field.map)})` : '';
+    return `${fieldPath} ${field.name}${modifiers[field.mode]}${defaultValue}${map}${index}`;
+  }
+  if (field.kind === 'multi') {
+    return Object.entries(field.fields).map(([subField, field]) => printField(getDBFieldKeyForFieldOnMultiField(fieldPath, subField), field, datasourceName, lists)).join('\n');
+  }
+  if (field.kind === 'relation') {
+    if (field.mode === 'many') return `${fieldPath} ${field.list}[] @relation("${field.relationName}")`;
+    if (field.foreignIdField.kind === 'none') return `${fieldPath} ${field.list}? @relation("${field.relationName}")`;
+    const relationIdFieldPath = `${fieldPath}Id`;
+    const relationField = `${fieldPath} ${field.list}? @relation("${field.relationName}", fields: [${relationIdFieldPath}], references: [id])`;
+    const foreignList = lists[field.list];
+    const foreignIdField = foreignList.resolvedDbFields.id;
+    assertDbFieldIsValidForIdField(foreignList.listKey, foreignList.isSingleton, foreignIdField);
+    const nativeType = printNativeType(foreignIdField.nativeType, datasourceName);
+    const foreignIndex = field.foreignIdField.kind === 'owned' ? 'index' : 'unique';
+    const index = printIndex(relationIdFieldPath, foreignIndex);
+    const relationIdField = `${relationIdFieldPath} ${foreignIdField.scalar}? @map(${JSON.stringify(field.foreignIdField.map)}) ${nativeType}${index}`;
+    return `${relationField}\n${relationIdField}`;
+  }
+  // TypeScript's control flow analysis doesn't understand that this will never happen without the assertNever
+  // (this will still correctly validate if any case is unhandled though)
+  return assertNever(field);
+}
+function collectEnums(lists) {
+  const enums = {};
+  for (const [listKey, {
+    resolvedDbFields
+  }] of Object.entries(lists)) {
+    for (const [fieldPath, field] of Object.entries(resolvedDbFields)) {
+      const fields = field.kind === 'multi' ? Object.entries(field.fields).map(([key, field]) => [field, `${listKey}.${fieldPath} (sub field ${key})`]) : [[field, `${listKey}.${fieldPath}`]];
+      for (const [field, ref] of fields) {
+        if (field.kind !== 'enum') continue;
+        const alreadyExistingEnum = enums[field.name];
+        if (alreadyExistingEnum === undefined) {
+          enums[field.name] = {
+            values: field.values,
+            firstDefinedByRef: ref
+          };
+          continue;
+        }
+        if (!areArraysEqual(alreadyExistingEnum.values, field.values)) {
+          throw new Error(`The fields ${alreadyExistingEnum.firstDefinedByRef} and ${ref} both specify Prisma schema enums` + `with the name ${field.name} but they have different values:\n` + `enum from ${alreadyExistingEnum.firstDefinedByRef}:\n${JSON.stringify(alreadyExistingEnum.values, null, 2)}\n` + `enum from ${ref}:\n${JSON.stringify(field.values, null, 2)}`);
+        }
+      }
+    }
+  }
+  return Object.entries(enums).map(([enumName, {
+    values
+  }]) => `enum ${enumName} {\n${values.join('\n')}\n}`).join('\n');
+}
+function assertDbFieldIsValidForIdField(listKey, isSingleton, field) {
+  if (field.kind !== 'scalar') {
+    throw new Error(`id fields must be either a String or Int Prisma scalar but the id field for the ${listKey} list is not a scalar`);
+  }
+  // this may be loosened in the future
+  if (field.scalar !== 'String' && field.scalar !== 'Int' && field.scalar !== 'BigInt') {
+    throw new Error(`id fields must be String, Int or BigInt Prisma scalars but the id field for the ${listKey} list is a ${field.scalar} scalar`);
+  }
+  if (field.mode !== 'required') {
+    throw new Error(`id fields must be a singular required field but the id field for the ${listKey} list is ${field.mode === 'many' ? 'a many' : 'an optional'} field`);
+  }
+  if (field.index !== undefined) {
+    throw new Error(`id fields must not specify indexes themselves but the id field for the ${listKey} list specifies an index`);
+  }
+}
+function printPrismaSchema(config, lists) {
+  var _extendPrismaComplete;
+  const {
+    prismaClientPath,
+    provider,
+    extendPrismaSchema: extendPrismaCompleteSchema
+  } = config.db;
+  const prismaSchema = [`// This file is automatically generated by Nixxie, do not modify it manually.`, `// Modify your Nixxie config when you want to change this.`, ``, `datasource ${provider} {`, `  url = env("DATABASE_URL")`, `  shadowDatabaseUrl = env("SHADOW_DATABASE_URL")`, `  provider = "${provider}"`, `}`, ``, `generator client {`, `  provider = "prisma-client-js"`, ...(prismaClientPath === '@prisma/client' ? [] : [`  output = "${prismaClientPath}"`]), '}'];
+  for (const [listKey, {
+    resolvedDbFields,
+    prisma: {
+      mapping,
+      extendPrismaSchema: extendPrismaListSchema
+    },
+    isSingleton
+  }] of Object.entries(lists)) {
+    const listPrisma = [`model ${listKey} {`];
+    for (const [fieldPath, field] of Object.entries(resolvedDbFields)) {
+      if (fieldPath === 'id') {
+        assertDbFieldIsValidForIdField(listKey, isSingleton, field);
+      }
+      if (field.kind !== 'none') {
+        let fieldPrisma = printField(fieldPath, field, provider, lists);
+        if (fieldPath === 'id') {
+          fieldPrisma += ' @id';
+        }
+        listPrisma.push(field.extendPrismaSchema ? field.extendPrismaSchema(fieldPrisma) : fieldPrisma);
+      }
+    }
+    if (mapping !== undefined) {
+      listPrisma.push(`@@map(${JSON.stringify(mapping)})`);
+    }
+    listPrisma.push('}');
+    const listPrismaStr = listPrisma.join('\n');
+    prismaSchema.push(extendPrismaListSchema ? extendPrismaListSchema(listPrismaStr) : listPrismaStr);
+  }
+  prismaSchema.push(collectEnums(lists));
+  const prismaSchemaStr = prismaSchema.join('\n');
+  return (_extendPrismaComplete = extendPrismaCompleteSchema === null || extendPrismaCompleteSchema === void 0 ? void 0 : extendPrismaCompleteSchema(prismaSchemaStr)) !== null && _extendPrismaComplete !== void 0 ? _extendPrismaComplete : prismaSchemaStr;
+}
+
+const introspectionTypesSet = new Set(introspectionTypes);
+
+// note this is the types for scalars as _input_ types
+// and before scalar parsing
+const SCALARS = {
+  ID: 'string',
+  Boolean: 'boolean',
+  String: 'string',
+  Int: 'number',
+  Float: 'number',
+  JSON: `import('@nixxie-cms/core/types').JSONValue`,
+  Decimal: `import('@nixxie-cms/core/types').Decimal | string`,
+  Empty: `{}`
+};
+function stringify(x) {
+  return JSON.stringify(x).slice(1, -1);
+}
+function printTypeReference(type) {
+  if (type instanceof GraphQLNonNull) return printTypeReferenceWithoutNullable(type.ofType);
+  return `${printTypeReferenceWithoutNullable(type)} | null`;
+}
+function printTypeReferenceWithoutNullable(type) {
+  if (type instanceof GraphQLList) return `ReadonlyArray<${printTypeReference(type.ofType)}> | ${printTypeReference(type.ofType)}`;
+  const name = type.name;
+  if (type instanceof GraphQLScalarType) {
+    if (name in SCALARS) return SCALARS[name];
+    return `any`;
+  }
+  return name;
+}
+function printInterimType(prismaClientPath, list, operation) {
+  const name = list.prisma.types[`${operation}InputName`];
+  const prismaType = `import('${prismaClientPath}').Prisma.${name}`;
+  return [`type Resolved${name} = {`, ...Object.entries(list.fields).map(([fieldKey, {
+    dbField,
+    graphql
+  }]) => {
+    if (dbField.kind === 'none') return `  ${fieldKey}?: undefined`;
+
+    // TODO: this could be elsewhere, maybe id-field.ts
+    if (fieldKey === 'id') {
+      // autoincrement doesn't support passing an identifier
+      if ('default' in dbField) {
+        var _dbField$default;
+        if (((_dbField$default = dbField.default) === null || _dbField$default === void 0 ? void 0 : _dbField$default.kind) === 'autoincrement') {
+          return `  id?: undefined`;
+        }
+      }
+
+      // soft-block `id` updates for relationship safety
+      if (operation === 'update') return `  id?: undefined`;
+    }
+    if (dbField.kind === 'multi') {
+      return [`  ${fieldKey}: {`, ...Object.entries(dbField.fields).map(([subFieldKey, subDbField]) => {
+        const optional = operation === 'create' && subDbField.mode === 'required' && !subDbField.default ? '' : '?';
+        return `  ${subFieldKey}${optional}: ${prismaType}['${fieldKey}_${subFieldKey}']`;
+      }), `  }`].join('\n');
+    }
+    const optional = operation === 'create' && dbField.mode === 'required' && !dbField.default || graphql.isNonNull[operation] ? '' : '?';
+    return `  ${fieldKey}${optional}: ${prismaType}['${fieldKey}']`;
+  }), `}`].join('\n');
+}
+function printGeneratedTypes(prismaClientPath, graphQLSchema, lists) {
+  prismaClientPath = stringify(prismaClientPath).replace(/'/g, `\\'`);
+  return ['/* eslint-disable */', '', [...function* () {
+    for (const type of Object.values(graphQLSchema.getTypeMap())) {
+      // We don't want to print TS types for the built-in GraphQL introspection types
+      // they won't be used for anything we want to print here.
+      if (introspectionTypesSet.has(type)) continue;
+      if (type instanceof GraphQLInputObjectType) {
+        yield [`export type ${type.name} = {`, ...function* () {
+          for (const {
+            name,
+            type: type_
+          } of Object.values(type.getFields())) {
+            const maybe = type_ instanceof GraphQLNonNull ? '' : '?';
+            yield `  readonly ${name}${maybe}: ${printTypeReference(type_)}`;
+          }
+        }(), '}'].join('\n');
+        continue;
+      }
+      if (type instanceof GraphQLEnumType) {
+        yield [`export type ${type.name} =`, type.getValues().map(x => `  | '${stringify(x.name)}'`).join('\n')].join('\n');
+        continue;
+      }
+      if (type.name === 'Empty') {
+        yield `export type Empty = {}`;
+        continue;
+      }
+    }
+  }()].join('\n\n'), '',
+  // Resolved* types
+  ...function* () {
+    for (const list of Object.values(lists)) {
+      yield printInterimType(prismaClientPath, list, 'create');
+      yield printInterimType(prismaClientPath, list, 'update');
+    }
+  }(), '', 'export declare namespace Lists {', ...function* () {
+    for (const [listKey, list] of Object.entries(lists)) {
+      const {
+        createInputName,
+        updateInputName
+      } = list.prisma.types;
+      const listTypeInfoName = `Lists.${listKey}.TypeInfo`;
+      yield [`export type ${listKey}<Session = any> = import('@nixxie-cms/core/types').ListConfig<${listTypeInfoName}<Session>>`, `namespace ${listKey} {`, `  export type Item = import('${prismaClientPath}').${listKey}`, `  export type TypeInfo<Session = any> = {`, `    key: '${listKey}'`, `    isSingleton: ${list.isSingleton}`, `    fields: ${Object.keys(list.fields).map(x => `'${x}'`).join(' | ')}`, `    actions: ${Object.values(list.actions).map(x => `'${x.actionKey}'`).join(' | ') || 'never'}`, `    item: Item`, `    inputs: {`, `      where: ${printTypeReferenceWithoutNullable(list.graphql.types.where)}`, `      uniqueWhere: ${printTypeReferenceWithoutNullable(list.graphql.types.uniqueWhere)}`, `      create: ${printTypeReferenceWithoutNullable(list.graphql.types.create)}`, `      update: ${printTypeReferenceWithoutNullable(list.graphql.types.update)}`, `      orderBy: ${printTypeReferenceWithoutNullable(list.graphql.types.orderBy)}`, `    }`, `    prisma: {`, `      create: Resolved${createInputName}`, `      update: Resolved${updateInputName}`, `    }`, `    all: __TypeInfo<Session>`, `  }`, `}`].map(line => `  ${line}`).join('\n');
+    }
+  }(), '}', `export type Context<Session = any> = import('@nixxie-cms/core/types').NixxieContext<TypeInfo<Session>>`, `export type Config<Session = any> = import('@nixxie-cms/core/types').NixxieConfig<TypeInfo<Session>>`, '', 'export type TypeInfo<Session = any> = {', `  lists: {`, ...function* () {
+    for (const listKey in lists) {
+      yield `    readonly ${listKey}: Lists.${listKey}.TypeInfo<Session>`;
+    }
+  }(), `  }`, `  prisma: import('${prismaClientPath}').PrismaClient`, `  session: Session`, `}`, ``,
+  // we need to reference the `TypeInfo` above in another type that is also called `TypeInfo`
+  `type __TypeInfo<Session = any> = TypeInfo<Session>`, ``, `export type Lists<Session = any> = {`, `  [Key in keyof TypeInfo['lists']]?: import('@nixxie-cms/core/types').ListConfig<TypeInfo<Session>['lists'][Key]>`, `} & Record<string, import('@nixxie-cms/core/types').ListConfig<any>>`, ``, `export {}`, ``].join('\n');
+}
+
+function getFormattedGraphQLSchema(schema) {
+  return '# This file is automatically generated by Nixxie, do not modify it manually.\n' + '# Modify your Nixxie config when you want to change this.\n\n' + schema + '\n';
+}
+async function readFileOrUndefined(path) {
+  try {
+    return await fs.readFile(path, 'utf8');
+  } catch (err) {
+    if (err.code === 'ENOENT') return;
+    throw err;
+  }
+}
+async function validateArtifacts(cwd, system) {
+  await withSpan('validating artifacts', async () => {
+    const paths = system.getPaths(cwd);
+    const artifacts = await buildArtifacts(system);
+    const [writtenGraphQLSchema, writtenPrismaSchema] = await Promise.all([readFileOrUndefined(paths.schema.graphql), readFileOrUndefined(paths.schema.prisma)]);
+    if (writtenGraphQLSchema !== artifacts.graphql && writtenPrismaSchema !== artifacts.prisma) {
+      throw new Error('Your Prisma and GraphQL schemas are not up to date');
+    }
+    if (writtenGraphQLSchema !== artifacts.graphql) {
+      throw new Error('Your GraphQL schema is not up to date');
+    }
+    if (writtenPrismaSchema !== artifacts.prisma) {
+      throw new Error('Your Prisma schema is not up to date');
+    }
+  });
+}
+
+// exported for tests
+async function buildArtifacts(system) {
+  return await withSpan('building artifacts', async () => {
+    const prismaSchema = await formatSchema({
+      schemas: [[system.config.db.prismaSchemaPath, printPrismaSchema(system.config, system.lists)]]
+    });
+    return {
+      graphql: getFormattedGraphQLSchema(printSchema(system.graphql.schemas.public)),
+      prisma: prismaSchema[0][1]
+    };
+  });
+}
+async function generateArtifacts(cwd, system) {
+  return await withSpan('generating artifacts', async () => {
+    const paths = system.getPaths(cwd);
+    const artifacts = await buildArtifacts(system);
+    await fs.writeFile(paths.schema.graphql, artifacts.graphql);
+    await fs.writeFile(paths.schema.prisma, artifacts.prisma);
+    return artifacts;
+  });
+}
+async function generateTypes(cwd, system) {
+  return await withSpan('generating types', async () => {
+    const paths = system.getPaths(cwd);
+    const schema = printGeneratedTypes(paths.types.relativePrismaPath, system.graphql.schemas.internal, system.lists);
+    await fs.mkdir(path.dirname(paths.schema.types), {
+      recursive: true
+    });
+    await fs.writeFile(paths.schema.types, schema);
+  });
+}
+async function generatePrismaClient(cwd, system) {
+  return await withSpan('generating prisma client', async () => {
+    const paths = system.getPaths(cwd);
+    const generators = await getGenerators({
+      schemaPath: paths.schema.prisma,
+      registry: defaultRegistry.toInternal()
+    });
+    await Promise.all(generators.map(async generator => {
+      try {
+        await generator.generate();
+      } finally {
+        generator.stop();
+      }
+    }));
+  });
+}
+
+class ExitError extends Error {
+  constructor(code, message = '') {
+    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
+async function importBuiltNixxieConfiguration(cwd) {
+  const builtConfigPath = getBuiltNixxieConfigurationPath(cwd);
+  if (!(await fs.stat(builtConfigPath).catch(() => null))) {
+    throw new Error('You need to run "nixxie build"');
+  }
+  return require(builtConfigPath).default;
+}
+
+/*
+NOTE: This creates the main Nixxie express server, including the
+GraphQL API, but does NOT add the Admin UI middleware.
+
+The Admin UI takes a while to build for dev, and is created separately
+so the CLI can bring up the dev server early to handle GraphQL requests.
+*/
+
+function formatError(graphqlConfig) {
+  let debug = graphqlConfig.debug;
+  if (debug === undefined) {
+    debug = process.env.NODE_ENV !== 'production';
+  }
+  return (formattedError, error) => {
+    var _error$originalError, _graphqlConfig$apollo;
+    if (error instanceof GraphQLError && (_error$originalError = error.originalError) !== null && _error$originalError !== void 0 && _error$originalError.name.startsWith('Prisma')) {
+      formattedError = {
+        ...formattedError,
+        extensions: {
+          ...formattedError.extensions,
+          code: 'KS_PRISMA_ERROR'
+        },
+        message: 'Prisma error'
+      };
+    }
+    if (!debug && formattedError.extensions) {
+      // Strip out any `debug` extensions
+      delete formattedError.extensions.debug;
+      delete formattedError.extensions.exception;
+    }
+    if ((_graphqlConfig$apollo = graphqlConfig.apolloConfig) !== null && _graphqlConfig$apollo !== void 0 && _graphqlConfig$apollo.formatError) {
+      return graphqlConfig.apolloConfig.formatError(formattedError, error);
+    }
+    return formattedError;
+  };
+}
+async function createExpressServer(config, context) {
+  var _apolloConfig$plugins;
+  const expressServer = express();
+  const httpServer = createServer(expressServer);
+  if (config.server.cors !== null) {
+    expressServer.use(cors(config.server.cors));
+  }
+  await config.server.extendExpressApp(expressServer, context);
+  await config.server.extendHttpServer(httpServer, context);
+  const apolloConfig = config.graphql.apolloConfig;
+  const serverConfig = {
+    includeStacktraceInErrorResponses: config.graphql.debug,
+    ...apolloConfig,
+    formatError: formatError(config.graphql),
+    schema: context.graphql.schema,
+    plugins: config.graphql.playground === 'apollo' ? apolloConfig === null || apolloConfig === void 0 ? void 0 : apolloConfig.plugins : [config.graphql.playground ? ApolloServerPluginLandingPageLocalDefault() : ApolloServerPluginLandingPageDisabled(), ...((_apolloConfig$plugins = apolloConfig === null || apolloConfig === void 0 ? void 0 : apolloConfig.plugins) !== null && _apolloConfig$plugins !== void 0 ? _apolloConfig$plugins : [])]
+  }; // TODO: satisfies
+
+  const apolloServer = new ApolloServer({
+    ...serverConfig
+  });
+  const maxFileSize = config.server.maxFileSize;
+  expressServer.use(graphqlUploadExpress({
+    maxFileSize
+  }));
+  await apolloServer.start();
+  expressServer.use(config.graphql.path, json(config.graphql.bodyParser), (req, res, next) => {
+    var _req$body;
+    // WARNING: body-parser@^2 only sets .body if a .body is parsed, Apollo always wants .body to be set
+    (_req$body = req.body) !== null && _req$body !== void 0 ? _req$body : req.body = {};
+    next();
+  }, expressMiddleware(apolloServer, {
+    context: async ({
+      req,
+      res
+    }) => {
+      return await context.withRequest(req, res);
+    }
+  }));
+  return {
+    expressServer,
+    apolloServer,
+    httpServer
+  };
+}
+
+export { ExitError as E, generateTypes as a, generatePrismaClient as b, createExpressServer as c, getFormattedGraphQLSchema as d, buildArtifacts as e, generateArtifacts as g, importBuiltNixxieConfiguration as i, printPrismaSchema as p, validateArtifacts as v };