@nixxie-cms/core 1.0.0

package/src/admin-ui/utils/utils.tsx

@@ -0,0 +1,127 @@
+import isDeepEqual from 'fast-deep-equal'
+import { type FragmentDefinitionNode, type SelectionSetNode, parse } from 'graphql'
+import { useMemo } from 'react'
+
+import type {
+  BaseListTypeInfo,
+  ConditionalFilterCase,
+  FieldController,
+  FieldMeta,
+} from '../../types'
+import { serializeItemForConditionalFilters, testFilter } from './filters'
+
+function extractRootFields(selectedFields: Set<string>, selectionSet: SelectionSetNode) {
+  selectionSet.selections.forEach(selection => {
+    if (selection.kind === 'Field') {
+      selectedFields.add(selection.alias ? selection.alias.value : selection.name.value)
+    }
+    if (selection.kind === 'InlineFragment') {
+      extractRootFields(selectedFields, selection.selectionSet)
+    }
+    // FragmentSpread will never happen for the use cases of getRootFieldsFromSelection
+  })
+}
+
+export function getRootGraphQLFieldsFromFieldController(controller: FieldController<any, any>) {
+  const ast = parse(`fragment X on Y { id, ${controller.graphqlSelection} }`)
+  const selectedFields = new Set<string>()
+  const fragmentNode = ast.definitions[0] as FragmentDefinitionNode
+  extractRootFields(selectedFields, fragmentNode.selectionSet)
+  return [...selectedFields]
+}
+
+export function useInvalidFields(
+  fields: Record<string, FieldMeta>,
+  item: Record<string, unknown>,
+  isRequireds: Record<string, ConditionalFilterCase<BaseListTypeInfo>>
+): ReadonlySet<string> {
+  return useMemo(() => {
+    const invalidFields = new Set<string>()
+    const serialized = serializeItemForConditionalFilters(fields, item)
+
+    for (const fieldKey in item) {
+      const validateFn = fields[fieldKey]?.controller?.validate
+      if (!validateFn) continue
+      const isRequired = testFilter(isRequireds[fieldKey] ?? false, serialized)
+      const fieldValue = item[fieldKey]
+      const valid = validateFn(fieldValue, { isRequired })
+      if (valid) continue
+
+      invalidFields.add(fieldKey)
+    }
+    return invalidFields
+  }, [fields, isRequireds, item])
+}
+
+export function makeDefaultValueState(fields: Record<string, FieldMeta>) {
+  const result: Record<string, unknown> = {}
+  for (const fieldKey in fields) {
+    result[fieldKey] = fields[fieldKey].controller.defaultValue
+  }
+  return result
+}
+
+export function deserializeItemToValue(
+  fields: Record<string, FieldMeta>,
+  item: Record<string, unknown | null>
+) {
+  const result: Record<string, unknown | null> = {}
+  for (const [fieldKey, field] of Object.entries(fields)) {
+    const itemForField: Record<string, unknown> = {}
+    for (const graphqlField of getRootGraphQLFieldsFromFieldController(field.controller)) {
+      itemForField[graphqlField] = item?.[graphqlField] ?? null
+    }
+    result[fieldKey] = field.controller.deserialize(itemForField)
+  }
+  return result
+}
+
+export function serializeValueToOperationItem(
+  operation: 'create' | 'update',
+  fields: Record<string, FieldMeta>,
+  value: Record<string, unknown>,
+  valueReference?: Record<string, unknown>
+) {
+  const result: Record<string, unknown> = {}
+  valueReference ??= makeDefaultValueState(fields)
+
+  for (const fieldKey in fields) {
+    const field = fields[fieldKey]
+    const fieldValue = value[fieldKey]
+    const fieldValueSerialized = field.controller.serialize(fieldValue)
+    const fieldValueReference = valueReference[fieldKey]
+
+    const isAlwaysRequired = field.isNonNull.includes(operation)
+    if (!isAlwaysRequired) {
+      if (isDeepEqual(fieldValueSerialized, field.controller.serialize(fieldValueReference)))
+        continue
+    }
+
+    Object.assign(result, fieldValueSerialized)
+  }
+
+  return result
+}
+
+export function useHasChanges(
+  operation: 'create' | 'update',
+  fields: Record<string, FieldMeta>,
+  value: Record<string, unknown>,
+  valueReference?: Record<string, unknown>
+) {
+  return useMemo(() => {
+    valueReference ??= makeDefaultValueState(fields)
+
+    for (const fieldKey in fields) {
+      const field = fields[fieldKey]
+      const fieldValue = value[fieldKey]
+      const fieldValueSerialized = field.controller.serialize(fieldValue)
+      const fieldValueReference = valueReference[fieldKey]
+
+      if (!isDeepEqual(fieldValueSerialized, field.controller.serialize(fieldValueReference)))
+        return true
+    }
+
+    return false
+  }, [fields, operation, value, valueReference])
+}

package/src/artifacts.ts

@@ -0,0 +1,110 @@
+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 { printSchema } from 'graphql'
+import { printPrismaSchema } from './lib/core/prisma-schema-printer'
+import { withSpan } from './lib/otel'
+import type { System } from './lib/system'
+import { printGeneratedTypes } from './lib/typescript-schema-printer'
+
+export function getFormattedGraphQLSchema(schema: string) {
+  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: string) {
+  try {
+    return await fs.readFile(path, 'utf8')
+  } catch (err: any) {
+    if (err.code === 'ENOENT') return
+    throw err
+  }
+}
+
+export async function validateArtifacts(cwd: string, system: 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
+export async function buildArtifacts(system: 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],
+    }
+  })
+}
+
+export async function generateArtifacts(cwd: string, system: 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
+  })
+}
+
+export async function generateTypes(cwd: string, system: 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)
+  })
+}
+
+export async function generatePrismaClient(cwd: string, system: 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()
+        }
+      })
+    )
+  })
+}

package/src/context.ts

@@ -0,0 +1 @@
+export { getContext } from './lib/system'

package/src/fields/filters/enum-filter.ts

@@ -0,0 +1,77 @@
+import type { GArg, GEnumType, GInputObjectType, GList, GNonNull } from '@graphql-ts/schema'
+import { g } from '../../types/schema'
+
+// yes, these two types have the fields but they're semantically different types
+// (even though, yes, having EnumFilter by defined as EnumNullableFilter<Enum>, would be the same type but names would show up differently in editors for example)
+
+export type EnumNullableFilter<Enum extends GEnumType<any>> = GInputObjectType<{
+  // can be null
+  equals: GArg<Enum>
+  // can be null
+  in: GArg<GList<GNonNull<Enum>>>
+  // can be null
+  notIn: GArg<GList<GNonNull<Enum>>>
+  // can be null
+  not: GArg<EnumNullableFilter<Enum>>
+}>
+
+export type EnumFilter<Enum extends GEnumType<any>> = GInputObjectType<{
+  equals: GArg<Enum>
+  in: GArg<GList<GNonNull<Enum>>>
+  notIn: GArg<GList<GNonNull<Enum>>>
+  not: GArg<EnumFilter<Enum>>
+}>
+
+type EnumNullableListFilterType<Enum extends GEnumType<any>> = GInputObjectType<{
+  // can be null
+  equals: GArg<GList<GNonNull<Enum>>>
+  // can be null
+  has: GArg<Enum>
+  hasEvery: GArg<GList<GNonNull<Enum>>>
+  hasSome: GArg<GList<GNonNull<Enum>>>
+  isEmpty: GArg<Enum>
+}>
+
+export function enumFilters<Enum extends GEnumType<any>>(
+  enumType: Enum
+): {
+  optional: EnumNullableFilter<Enum>
+  required: EnumFilter<Enum>
+  many: EnumNullableListFilterType<Enum>
+} {
+  const optional: EnumNullableFilter<Enum> = g.inputObject({
+    name: `${enumType.name}NullableFilter`,
+    fields: () => ({
+      equals: g.arg({ type: enumType }),
+      in: g.arg({ type: g.list(g.nonNull(enumType)) }),
+      notIn: g.arg({ type: g.list(g.nonNull(enumType)) }),
+      not: g.arg({ type: optional }),
+    }),
+  })
+  const required: EnumFilter<Enum> = g.inputObject({
+    name: `${enumType.name}Filter`,
+    fields: () => ({
+      equals: g.arg({ type: enumType }),
+      in: g.arg({ type: g.list(g.nonNull(enumType)) }),
+      notIn: g.arg({ type: g.list(g.nonNull(enumType)) }),
+      not: g.arg({ type: optional }),
+    }),
+  })
+  const many: EnumNullableListFilterType<Enum> = g.inputObject({
+    name: `${enumType.name}NullableListFilter`,
+    fields: () => ({
+      // can be null
+      equals: g.arg({ type: g.list(g.nonNull(enumType)) }),
+      // can be null
+      has: g.arg({ type: enumType }),
+      hasEvery: g.arg({ type: g.list(g.nonNull(enumType)) }),
+      hasSome: g.arg({ type: g.list(g.nonNull(enumType)) }),
+      isEmpty: g.arg({ type: enumType }),
+    }),
+  })
+  return {
+    optional,
+    required,
+    many,
+  }
+}

package/src/fields/filters/index.ts

@@ -0,0 +1 @@
+export * as filters from './internal'

package/src/fields/filters/internal.ts

@@ -0,0 +1,89 @@
+export * as postgresql from './providers/postgresql'
+export * as sqlite from './providers/sqlite'
+export * as mysql from './providers/mysql'
+
+type EntriesAssumingNoExtraProps<T> = {
+  [Key in keyof T]-?: [Key, T[Key]]
+}[keyof T][]
+
+const objectEntriesButAssumeNoExtraProperties: <T>(obj: T) => EntriesAssumingNoExtraProps<T> =
+  Object.entries as any
+
+type CommonFilter<T> = {
+  equals?: T | null
+  in?: readonly T[] | null
+  notIn?: readonly T[] | null
+  lt?: T | null
+  lte?: T | null
+  gt?: T | null
+  gte?: T | null
+  contains?: T | null
+  startsWith?: T | null
+  endsWith?: T | null
+  not?: CommonFilter<T> | null
+}
+
+function internalResolveFilter(
+  entries: EntriesAssumingNoExtraProps<CommonFilter<any>>,
+  mode: 'default' | 'insensitive' | undefined
+): object {
+  const entry = entries.shift()
+  if (entry === undefined) return {}
+  const [key, val] = entry
+  if (val == null) {
+    return {
+      AND: [{ [key]: val }, internalResolveFilter(entries, mode)],
+    }
+  }
+  switch (key) {
+    case 'equals':
+    case 'lt':
+    case 'lte':
+    case 'gt':
+    case 'gte':
+    case 'in':
+    case 'contains':
+    case 'startsWith':
+    case 'endsWith': {
+      return {
+        AND: [{ [key]: val, mode }, { not: null }, internalResolveFilter(entries, mode)],
+      }
+    }
+
+    case 'notIn': {
+      return {
+        AND: [
+          {
+            NOT: [
+              internalResolveFilter(objectEntriesButAssumeNoExtraProperties({ in: val }), mode),
+            ],
+          },
+          internalResolveFilter(entries, mode),
+        ],
+      }
+    }
+    case 'not': {
+      return {
+        AND: [
+          {
+            NOT: [internalResolveFilter(objectEntriesButAssumeNoExtraProperties(val), mode)],
+          },
+          internalResolveFilter(entries, mode),
+        ],
+      }
+    }
+  }
+}
+
+export function resolveCommon(val: CommonFilter<any> | null) {
+  if (val === null) return null
+  return internalResolveFilter(objectEntriesButAssumeNoExtraProperties(val), undefined)
+}
+
+export function resolveString(
+  val: (CommonFilter<string> & { mode?: 'default' | 'insensitive' | null }) | null
+) {
+  if (val === null) return null
+  const { mode, ...value } = val
+  return internalResolveFilter(objectEntriesButAssumeNoExtraProperties(value), mode ?? undefined)
+}