@nixxie-cms/core 1.0.0

package/src/lib/telemetry.ts

@@ -0,0 +1,342 @@
+import { platform } from 'node:os'
+import https from 'node:https'
+
+import ci from 'ci-info'
+import Conf from 'conf'
+import { bold, blue as b, yellow as y, red as r, green as g, grey } from 'chalk'
+import type { Device, Project, TelemetryVersion1, TelemetryVersion2 } from '../types/telemetry'
+import type { DatabaseProvider } from '../types'
+import type { InitialisedList } from './core/initialise-lists'
+
+const defaultTelemetryEndpoint = 'https://telemetry.nixxiecms.com/3/'
+
+function log(message: unknown) {
+  if (process.env.KEYSTONE_TELEMETRY_DEBUG === '1') {
+    console.log(`${message}`)
+  }
+}
+
+type Telemetry = TelemetryVersion2
+type TelemetryOK = Exclude<Telemetry, false | undefined>
+type Configuration = ReturnType<typeof getTelemetryConfig>['userConfig']
+
+function getTelemetryConfig() {
+  const userConfig = new Conf<{
+    telemetry?: TelemetryVersion2
+  }>({
+    projectName: 'nixxiecms',
+    projectSuffix: '',
+    projectVersion: '3.0.0',
+    migrations: {
+      '^2.0.0': store => {
+        const existing = store.get('telemetry') as TelemetryVersion1
+        if (!existing) return // skip non-configured or known opt-outs
+
+        const replacement: TelemetryVersion2 = {
+          informedAt: null, // re-inform
+          device: {
+            lastSentDate: existing.device.lastSentDate ?? 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 satisfies TelemetryVersion2)
+      },
+      '^3.0.0': store => {
+        const existing = store.get('telemetry') as TelemetryVersion2
+        if (!existing) return // skip non-configured or known opt-outs
+
+        store.set('telemetry', {
+          ...existing,
+          informedAt: null, // re-inform
+        } satisfies Telemetry)
+      },
+    },
+  })
+
+  return {
+    telemetry: userConfig.get('telemetry'),
+    userConfig,
+  }
+}
+
+function getDefault(telemetry: Telemetry) {
+  if (telemetry) return telemetry
+  return {
+    informedAt: null,
+    device: {
+      lastSentDate: null,
+    },
+    projects: {},
+  } satisfies Telemetry // help Typescript infer the type
+}
+
+const todaysDate = new Date().toISOString().slice(0, 10)
+
+function collectFieldCount(lists: Record<string, InitialisedList>) {
+  const fields: Project['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] ||= 0
+      fields[fieldType] += 1
+    }
+  }
+
+  return fields
+}
+
+async function collectPackageVersions() {
+  const packages: Project['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: Telemetry) {
+  if (!telemetry) {
+    console.log(`Telemetry data will ${r`not`} be sent by this system user`)
+    return
+  }
+  console.log(`Telemetry data will be sent the next time you run ${g`"nixxie dev"`}`)
+}
+
+function printTelemetryStatus(telemetry: Telemetry, updated = false) {
+  const auxverb = updated ? 'has been' : 'is'
+
+  if (telemetry === undefined) {
+    console.log(`Nixxie telemetry ${auxverb} ${y`uninitialized`}`)
+    console.log()
+    printNext(telemetry)
+    return
+  }
+
+  if (telemetry === false) {
+    console.log(`Nixxie telemetry ${auxverb} ${r`disabled`}`)
+    console.log()
+    printNext(telemetry)
+    return
+  }
+
+  console.log(`Nixxie telemetry ${auxverb} ${g`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 "${y(projectPath)}" was last sent on ${project?.lastSentDate}`
+    )
+  }
+
+  console.log()
+  printNext(telemetry)
+}
+
+function inform(telemetry: TelemetryOK, userConfig: Configuration) {
+  console.log() // gap to help visiblity
+  console.log(`${bold('Nixxie Telemetry')}`)
+  console.log(`${y`Nixxie collects anonymous data when you run`} ${g`"nixxie dev"`}`)
+  console.log(
+    `You can use ${g`"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 ${grey`https://nixxiecms.com/telemetry`} (updated ${b`2024-08-20`})`
+  )
+
+  // update the informedAt
+  telemetry.informedAt = new Date().toJSON()
+  userConfig.set('telemetry', telemetry)
+}
+
+async function sendEvent(eventType: 'project', eventData: Project): Promise<void>
+async function sendEvent(eventType: 'device', eventData: Device): Promise<void>
+async function sendEvent(eventType: 'project' | 'device', eventData: Project | Device) {
+  const endpoint = process.env.KEYSTONE_TELEMETRY_ENDPOINT || defaultTelemetryEndpoint
+  await new Promise<void>(resolve => {
+    const req = https.request(
+      `${endpoint}${eventType}`,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      },
+      () => resolve()
+    )
+
+    req.once('error', err => {
+      log(err?.message ?? err)
+      resolve()
+    })
+    req.end(JSON.stringify(eventData))
+  })
+
+  log(`sent ${eventType} report`)
+}
+
+async function sendProjectTelemetryEvent(
+  cwd: string,
+  lists: Record<string, InitialisedList>,
+  dbProviderName: DatabaseProvider,
+  telemetry: TelemetryOK,
+  userConfig: Configuration
+) {
+  const project = telemetry.projects[cwd] ?? { 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: TelemetryOK, userConfig: Configuration) {
+  const { lastSentDate } = telemetry.device
+  if (lastSentDate && lastSentDate === todaysDate) {
+    log('device telemetry already sent today')
+    return
+  }
+
+  await sendEvent('device', {
+    lastSentDate,
+    os: platform(),
+    node: process.versions.node.split('.')[0],
+  })
+
+  // update the device lastSentDate
+  telemetry.device = { lastSentDate: todaysDate }
+  userConfig.set('telemetry', telemetry)
+}
+
+export async function runTelemetry(
+  cwd: string,
+  lists: Record<string, InitialisedList>,
+  dbProviderName: DatabaseProvider
+) {
+  try {
+    if (ci.isCI) {
+      console.log(`Nixxie Telemetry is ${r`disabled`} (running in CI)`)
+      return
+    }
+
+    const { telemetry, userConfig } = getTelemetryConfig()
+    if (telemetry === false) {
+      console.log(`Nixxie Telemetry is ${r`disabled`} (via opt-out)`)
+      return
+    }
+
+    if (process.env.NIXXIE_TELEMETRY_DISABLED === '1') {
+      console.log(`Nixxie Telemetry is ${r`disabled`} (NIXXIE_TELEMETRY_DISABLED is set)`)
+      return
+    }
+
+    if (process.env.DO_NOT_TRACK === '1') {
+      console.log(`Nixxie Telemetry is ${r`disabled`} (DO_NOT_TRACK is set)`)
+      return
+    }
+
+    if (process.env.NODE_ENV === 'production') {
+      console.log(`Nixxie Telemetry is ${r`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 ${g`enabled`}`)
+
+    await sendProjectTelemetryEvent(cwd, lists, dbProviderName, telemetryDefaulted, userConfig)
+    await sendDeviceTelemetryEvent(telemetryDefaulted, userConfig)
+  } catch (err: any) {
+    log(err?.message ?? err)
+  }
+}
+export function statusTelemetry(updated = false) {
+  const { telemetry } = getTelemetryConfig()
+  printTelemetryStatus(telemetry, updated)
+}
+
+export function informTelemetry() {
+  const { userConfig } = getTelemetryConfig()
+  inform(getDefault(false), userConfig)
+}
+
+export function enableTelemetry() {
+  const { telemetry, userConfig } = getTelemetryConfig()
+  if (!telemetry) {
+    userConfig.set('telemetry', getDefault(telemetry))
+  }
+  statusTelemetry(true)
+}
+
+export function disableTelemetry() {
+  const { userConfig } = getTelemetryConfig()
+  userConfig.set('telemetry', false)
+  statusTelemetry(true)
+}
+
+export function resetTelemetry() {
+  const { userConfig } = getTelemetryConfig()
+  userConfig.delete('telemetry')
+  statusTelemetry(true)
+}

package/src/lib/typescript-schema-printer.ts

@@ -0,0 +1,227 @@
+import {
+  type GraphQLNamedType,
+  type GraphQLSchema,
+  type GraphQLType,
+  GraphQLEnumType,
+  GraphQLInputObjectType,
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLScalarType,
+  introspectionTypes,
+} from 'graphql'
+import type { InitialisedList } from './core/initialise-lists'
+
+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: `{}`,
+} as const
+
+function stringify(x: string) {
+  return JSON.stringify(x).slice(1, -1)
+}
+
+function printTypeReference(type: GraphQLType): string {
+  if (type instanceof GraphQLNonNull) return printTypeReferenceWithoutNullable(type.ofType)
+  return `${printTypeReferenceWithoutNullable(type)} | null`
+}
+
+function printTypeReferenceWithoutNullable(
+  type: GraphQLNamedType | GraphQLList<GraphQLType>
+): string {
+  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 as keyof typeof SCALARS]
+    return `any`
+  }
+
+  return name
+}
+
+function printInterimType<L extends InitialisedList>(
+  prismaClientPath: string,
+  list: L,
+  operation: 'create' | 'update'
+) {
+  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) {
+          if (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')
+}
+
+export function printGeneratedTypes(
+  prismaClientPath: string,
+  graphQLSchema: GraphQLSchema,
+  lists: Record<string, InitialisedList>
+) {
+  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')
+}

package/src/lib/utils.ts

@@ -0,0 +1,21 @@
+// WARNING: this is an opinionated subject, with too many ways to do this
+//   we went with a subset that we are happy with
+//   see tests2/utils.test.ts for examples
+export function humanize(s: string, capitalize: boolean = true) {
+  // drop non-alphanumeric
+  s = s.replace(/[^a-zA-Z0-9]+/g, ' ')
+
+  // insert spaces before camels of length > 1
+  for (let i = 0; i < 24; i++) {
+    // not unbounded, shouldnt happen
+    const next = s.replace(/([a-z0-9])([A-Z][A-Za-z0-9])/, '$1 $2')
+    if (next === s) break
+    s = next
+  }
+
+  if (!capitalize) return s
+  return s
+    .split(' ')
+    .map(x => x.charAt(0).toUpperCase() + x.slice(1))
+    .join(' ')
+}

package/src/pkg-dir.ts

@@ -0,0 +1,6 @@
+import path from 'path'
+import { createRequire } from 'node:module'
+
+export const pkgDir = path.dirname(
+  createRequire(__dirname).resolve('@nixxie-cms/core/package.json')
+)