@nixxie-cms/core 1.0.0

package/src/types/next-fields.ts

@@ -0,0 +1,499 @@
+import Decimal from 'decimal.js'
+import { g } from '../types/schema'
+import type { BaseListTypeInfo } from './type-info'
+import type { BaseFieldTypeInfo, CommonFieldConfig } from './config'
+import type { DatabaseProvider } from './core'
+import type {
+  GArg,
+  GInputType,
+  GNullableInputType,
+  InferValueFromArg,
+  GField,
+  GOutputType,
+  GInputObjectType,
+  GList,
+  GNonNull,
+  InferValueFromArgs,
+  GObjectType,
+  InferValueFromInputType,
+} from '@graphql-ts/schema'
+import type { JSONValue, NixxieContext, MaybePromise } from '.'
+import type { filters } from '../fields/filters'
+
+export { Decimal }
+
+export type BaseItem = { id: { toString(): string }; [key: string]: unknown }
+
+export type ListGraphQLTypes<ListTypeInfo extends BaseListTypeInfo> = {
+  types: GraphQLTypesForList<ListTypeInfo>
+}
+
+export type FieldData<ListTypeInfo extends BaseListTypeInfo = BaseListTypeInfo> = {
+  lists: {
+    [Key in keyof ListTypeInfo['all']['lists']]: ListGraphQLTypes<ListTypeInfo['all']['lists'][Key]>
+  }
+  provider: DatabaseProvider
+  listKey: ListTypeInfo['key']
+  fieldKey: string
+}
+
+type ScalarNames = Exclude<keyof (typeof filters)[DatabaseProvider], 'enum'>
+
+export type SimpleFieldTypeInfo<Scalar extends ScalarNames> = {
+  item: ScalarPrismaTypes[Scalar] | null
+  inputs: {
+    create: ScalarPrismaTypes[Scalar] | null | undefined
+    update: ScalarPrismaTypes[Scalar] | null | undefined
+    where: InferValueFromInputType<(typeof filters)[DatabaseProvider][Scalar]['required']> | null
+    uniqueWhere: ScalarPrismaTypes[Scalar] | null | undefined
+    orderBy: 'asc' | 'desc' | null
+  }
+  prisma: {
+    create:
+      | ScalarPrismaTypes[Scalar]
+      | { set?: ScalarPrismaTypes[Scalar] | null }
+      | null
+      | undefined
+    update:
+      | ScalarPrismaTypes[Scalar]
+      | { set?: ScalarPrismaTypes[Scalar] | null }
+      | null
+      | undefined
+  }
+}
+
+export type FieldTypeFunc<ListTypeInfo extends BaseListTypeInfo> = (
+  data: FieldData<ListTypeInfo>
+) => NextFieldType<
+  DBField,
+  GArg<GInputType> | undefined,
+  GArg<GInputType>,
+  GArg<GNullableInputType, false>,
+  GArg<GNullableInputType, false>,
+  GArg<GNullableInputType, false>,
+  ListTypeInfo
+>
+
+export type NextFieldType<
+  TDBField extends DBField = DBField,
+  CreateArg extends GArg<GInputType> | undefined = GArg<GInputType> | undefined,
+  UpdateArg extends GArg<GInputType> = GArg<GInputType>,
+  UniqueWhereArg extends GArg<GNullableInputType, false> = GArg<GNullableInputType, false>,
+  OrderByArg extends GArg<GNullableInputType, false> = GArg<GNullableInputType, false>,
+  FilterArg extends GArg<GNullableInputType, false> = GArg<GNullableInputType, false>,
+  ListTypeInfo extends BaseListTypeInfo = BaseListTypeInfo,
+> = {
+  dbField: TDBField
+} & FieldTypeWithoutDBField<
+  TDBField,
+  CreateArg,
+  UpdateArg,
+  UniqueWhereArg,
+  OrderByArg,
+  FilterArg,
+  ListTypeInfo
+>
+
+export type ScalarPrismaTypes = {
+  String: string
+  Boolean: boolean
+  Int: number
+  Float: number
+  DateTime: Date
+  BigInt: bigint
+  Json: JSONValue
+  Decimal: Decimal
+  Bytes: Uint8Array
+}
+
+type Literal<T> = {
+  kind: 'literal'
+  value: T
+}
+
+export type ScalarDBFieldDefault<
+  Scalar extends keyof ScalarPrismaTypes = keyof ScalarPrismaTypes,
+  Mode extends 'required' | 'many' | 'optional' = 'required' | 'many' | 'optional',
+> = Mode extends 'many'
+  ? never
+  :
+      | {
+          String:
+            | Literal<string>
+            | { kind: 'uuid'; version?: 4 | 7 }
+            | { kind: 'cuid'; version?: 1 | 2 }
+            | { kind: 'ulid' }
+            | { kind: 'nanoid'; length?: number }
+            | { kind: 'random'; bytes: number; encoding: 'hex' | 'base64url' }
+          Boolean: Literal<boolean>
+          Json: Literal<string>
+          Float: Literal<number>
+          Int: Literal<number> | { kind: 'autoincrement' }
+          BigInt: Literal<bigint> | { kind: 'autoincrement' }
+          DateTime: Literal<string> | { kind: 'now' }
+          Decimal: Literal<string>
+          Bytes: Literal<Uint8Array>
+        }[Scalar]
+      | { kind: 'dbgenerated'; value: string }
+
+export type ScalarDBField<
+  Scalar extends keyof ScalarPrismaTypes,
+  Mode extends 'required' | 'many' | 'optional',
+> = {
+  kind: 'scalar'
+  scalar: Scalar
+  mode: Mode
+  default?: ScalarDBFieldDefault<Scalar, Mode> | undefined
+  extendPrismaSchema?: (field: string) => string
+  index?: 'unique' | 'index' | undefined
+
+  map?: string
+  nativeType?: string
+  updatedAt?: Scalar extends 'DateTime' ? boolean : never
+}
+
+export type RelationDBField<Mode extends 'many' | 'one'> = {
+  kind: 'relation'
+  mode: Mode
+  extendPrismaSchema?: (field: string) => string
+
+  list: string
+  field?: string
+  foreignKey?: { one: true | { map: string }; many: undefined }[Mode]
+  relationName?: { one: undefined; many: string }[Mode]
+}
+
+export type EnumDBField<Value extends string, Mode extends 'required' | 'many' | 'optional'> = {
+  kind: 'enum'
+  name: string
+  mode: Mode
+  default?: { kind: 'literal'; value: Value }
+  extendPrismaSchema?: (field: string) => string
+  index?: 'unique' | 'index'
+
+  map?: string
+  values: readonly Value[]
+}
+
+export const orderDirectionEnum = g.enum({
+  name: 'OrderDirection',
+  values: g.enumValues(['asc', 'desc']),
+})
+
+export const QueryMode = g.enum({
+  name: 'QueryMode',
+  values: g.enumValues(['default', 'insensitive']),
+})
+
+export type NoDBField = { kind: 'none' }
+
+// TODO: merge
+export type ScalarishDBField =
+  | ScalarDBField<keyof ScalarPrismaTypes, 'required' | 'many' | 'optional'>
+  | EnumDBField<string, 'required' | 'many' | 'optional'>
+
+export type RealDBField = ScalarishDBField | RelationDBField<'many' | 'one'>
+
+export type MultiDBField<Fields extends Record<string, ScalarishDBField>> = {
+  kind: 'multi'
+  fields: Fields
+  extendPrismaSchema?: (field: string) => string
+}
+
+export type DBField = RealDBField | NoDBField | MultiDBField<Record<string, ScalarishDBField>>
+
+// TODO: this isn't right for create
+// for create though, db level defaults need to be taken into account for when to not allow undefined
+type DBFieldToInputValue<TDBField extends DBField> =
+  TDBField extends ScalarDBField<infer Scalar, infer Mode>
+    ? {
+        optional: ScalarPrismaTypes[Scalar] | null | undefined
+        required: ScalarPrismaTypes[Scalar] | undefined
+        many: readonly ScalarPrismaTypes[Scalar][] | undefined
+      }[Mode]
+    : TDBField extends RelationDBField<'many' | 'one'>
+      ? { connect?: object; disconnect?: boolean } | undefined
+      : TDBField extends EnumDBField<infer Value, infer Mode>
+        ? {
+            optional: Value | null | undefined
+            required: Value | undefined
+            many: readonly Value[] | undefined
+          }[Mode]
+        : TDBField extends NoDBField
+          ? undefined
+          : TDBField extends MultiDBField<infer Fields>
+            ? // note: this is very intentionally not optional and DBFieldToInputValue will add | undefined to force people to explicitly show what they are not setting
+              { [Key in keyof Fields]: DBFieldToInputValue<Fields[Key]> }
+            : never
+
+type DBFieldUniqueWhere<TDBField extends DBField> =
+  TDBField extends ScalarDBField<infer Scalar, 'optional' | 'required'>
+    ? Scalar extends 'String' | 'Int'
+      ? {
+          String: string
+          Int: number
+        }[Scalar]
+      : any
+    : any
+
+type DBFieldToOutputValue<TDBField extends DBField> =
+  TDBField extends ScalarDBField<infer Scalar, infer Mode>
+    ? {
+        optional: ScalarPrismaTypes[Scalar] | null
+        required: ScalarPrismaTypes[Scalar]
+        many: readonly ScalarPrismaTypes[Scalar][]
+      }[Mode]
+    : TDBField extends RelationDBField<infer Mode>
+      ? {
+          one: () => Promise<BaseItem>
+          many: {
+            findMany(args: FindManyArgsValue): Promise<BaseItem[]>
+            count(args: { where: FindManyArgsValue['where'] }): Promise<number>
+          }
+        }[Mode]
+      : TDBField extends EnumDBField<infer Value, infer Mode>
+        ? {
+            optional: Value | null
+            required: Value
+            many: readonly Value[]
+          }[Mode]
+        : TDBField extends NoDBField
+          ? undefined
+          : TDBField extends MultiDBField<infer Fields>
+            ? { [Key in keyof Fields]: DBFieldToOutputValue<Fields[Key]> }
+            : never
+
+export type OrderByFieldInputArg<Val, TArg extends GArg<GNullableInputType>> = {
+  arg: TArg
+} & ResolveFunc<
+  (
+    value: Exclude<InferValueFromArg<TArg>, null | undefined>,
+    context: NixxieContext
+  ) => MaybePromise<Val>
+>
+
+type FieldInputResolver<Input, Output, RelationshipInputResolver> = (
+  value: Input,
+  context: NixxieContext,
+  relationshipInputResolver: RelationshipInputResolver
+) => MaybePromise<Output>
+
+type DBFieldFiltersInner<TDBField extends DBField> = Record<string, any>
+
+type DBFieldFilters<TDBField extends DBField> =
+  | ({
+      AND?: DBFieldFiltersInner<TDBField>
+      OR?: DBFieldFiltersInner<TDBField>
+      NOT?: DBFieldFiltersInner<TDBField>
+    } & DBFieldFiltersInner<TDBField>)
+  | null
+
+export type WhereFieldInputArg<TDBField extends DBField, TArg extends GArg<GInputType, any>> = {
+  arg: TArg
+} & ResolveFunc<
+  FieldInputResolver<
+    Exclude<InferValueFromArg<TArg>, undefined>,
+    DBFieldFilters<TDBField>,
+    any
+    // i think this is broken because variance?
+    // TDBField extends RelationDBField<infer Mode>
+    //   ? (
+    //       input: {
+    //         many: types.InferValueFromArg<types.Arg<TypesForList['manyRelationWhere']>>;
+    //         one: types.InferValueFromArg<types.Arg<TypesForList['where']>>;
+    //       }[Mode]
+    //     ) => Promise<any>
+    //   : undefined
+  >
+>
+
+export type UpdateFieldInputArg<TDBField extends DBField, TArg extends GArg<GInputType, any>> = {
+  arg: TArg
+} & ResolveFunc<
+  FieldInputResolver<
+    InferValueFromArg<TArg>,
+    DBFieldToInputValue<TDBField>,
+    any
+    // i think this is broken because variance?
+    // TDBField extends RelationDBField<infer Mode>
+    //   ? (
+    //       input: graphql.InferValueFromArg<graphql.Arg<TypesForList['relateTo'][Mode]['create']>>
+    //     ) => Promise<any>
+    //   : undefined
+  >
+>
+
+type CreateFieldInputResolver<Input, TDBField extends DBField> = FieldInputResolver<
+  Input,
+  DBFieldToInputValue<TDBField>,
+  any
+  // i think this is broken because variance?
+  // TDBField extends RelationDBField<infer Mode>
+  //   ? (
+  //       input: graphql.InferValueFromArg<graphql.Arg<TypesForList['relateTo'][Mode]['create']>>
+  //     ) => Promise<any>
+  //   : undefined
+>
+
+export type CreateFieldInputArg<
+  TDBField extends DBField,
+  TArg extends GArg<GInputType, any> | undefined,
+> = {
+  arg: TArg
+} & (TArg extends GArg<GInputType, any>
+  ? InferValueFromArg<TArg> extends DBFieldToInputValue<TDBField>
+    ? {
+        resolve?: CreateFieldInputResolver<InferValueFromArg<TArg>, TDBField>
+      }
+    : {
+        resolve: CreateFieldInputResolver<InferValueFromArg<TArg>, TDBField>
+      }
+  : {
+      resolve: CreateFieldInputResolver<undefined, TDBField>
+    })
+
+type UnwrapMaybePromise<T> = T extends Promise<infer Resolved> ? Resolved : T
+
+type ResolveFunc<Func extends (firstArg: any, ...args: any[]) => any> =
+  Parameters<Func>[0] extends UnwrapMaybePromise<ReturnType<Func>>
+    ? { resolve?: Func }
+    : { resolve: Func }
+
+export type UniqueWhereFieldInputArg<Val, TArg extends GArg<GInputType>> = {
+  arg: TArg
+} & ResolveFunc<
+  (
+    value: Exclude<InferValueFromArg<TArg>, undefined | null>,
+    context: NixxieContext
+  ) => MaybePromise<Val>
+>
+
+type FieldTypeOutputField<TDBField extends DBField> = GField<
+  { value: DBFieldToOutputValue<TDBField>; item: BaseItem },
+  any,
+  GOutputType<NixxieContext>,
+  DBFieldToOutputValue<TDBField>,
+  NixxieContext
+>
+
+export type OrderDirection = 'asc' | 'desc'
+
+type DBFieldToOrderByValue<TDBField extends DBField> = TDBField extends ScalarishDBField
+  ? OrderDirection | undefined
+  : TDBField extends MultiDBField<infer Fields>
+    ? { [Key in keyof Fields]: DBFieldToOrderByValue<Fields[Key]> }
+    : undefined
+
+export type FieldTypeWithoutDBField<
+  TDBField extends DBField = DBField,
+  CreateArg extends GArg<GInputType> | undefined = GArg<GInputType> | undefined,
+  UpdateArg extends GArg<GInputType> = GArg<GInputType>,
+  UniqueWhereArg extends GArg<GNullableInputType, false> = GArg<GNullableInputType, false>,
+  OrderByArg extends GArg<GNullableInputType, false> = GArg<GNullableInputType, false>,
+  FilterArg extends GArg<GNullableInputType, false> = GArg<GNullableInputType, false>,
+  ListTypeInfo extends BaseListTypeInfo = BaseListTypeInfo,
+  FieldTypeInfo extends BaseFieldTypeInfo = BaseFieldTypeInfo,
+> = {
+  input?: {
+    uniqueWhere?: UniqueWhereFieldInputArg<DBFieldUniqueWhere<TDBField>, UniqueWhereArg>
+    where?: WhereFieldInputArg<TDBField, FilterArg>
+    create?: CreateFieldInputArg<TDBField, CreateArg>
+    update?: UpdateFieldInputArg<TDBField, UpdateArg>
+    orderBy?: OrderByFieldInputArg<DBFieldToOrderByValue<TDBField>, OrderByArg>
+  }
+  output: FieldTypeOutputField<TDBField>
+  views: string
+  extraOutputFields?: Record<string, FieldTypeOutputField<TDBField>>
+  getAdminMeta?: () => JSONValue
+  unreferencedConcreteInterfaceImplementations?: readonly g<typeof g.object<any>>[]
+  __ksTelemetryFieldTypeName?: string
+} & CommonFieldConfig<ListTypeInfo, FieldTypeInfo>
+
+type AnyInputObj = GInputObjectType<Record<string, GArg<GInputType>>>
+
+export type GraphQLTypesForList<ListTypeInfo extends BaseListTypeInfo = BaseListTypeInfo> = {
+  create: AnyInputObj | typeof g.Empty
+  update: AnyInputObj | typeof g.Empty
+  uniqueWhere: GInputObjectType<{
+    id: GArg<typeof g.ID>
+    [key: string]: GArg<GNullableInputType>
+  }>
+  where: AnyInputObj
+  orderBy: AnyInputObj
+  output: GObjectType<ListTypeInfo['item'], NixxieContext<ListTypeInfo['all']>>
+  findManyArgs: FindManyArgs
+  relateTo: {
+    one: {
+      create: GInputObjectType<{
+        create?: GArg<GraphQLTypesForList<ListTypeInfo>['create']>
+        connect: GArg<GraphQLTypesForList<ListTypeInfo>['uniqueWhere']>
+      }>
+      update: GInputObjectType<{
+        create?: GArg<GraphQLTypesForList<ListTypeInfo>['create']>
+        connect: GArg<GraphQLTypesForList<ListTypeInfo>['uniqueWhere']>
+        disconnect: GArg<typeof g.Boolean>
+      }>
+    }
+    many: {
+      where: GInputObjectType<{
+        every: GArg<AnyInputObj>
+        some: GArg<AnyInputObj>
+        none: GArg<AnyInputObj>
+      }>
+      create: GInputObjectType<{
+        create?: GArg<GList<GNonNull<GraphQLTypesForList<ListTypeInfo>['create']>>>
+        connect: GArg<GList<GNonNull<GraphQLTypesForList<ListTypeInfo>['uniqueWhere']>>>
+        set: GArg<GList<GNonNull<GraphQLTypesForList<ListTypeInfo>['uniqueWhere']>>>
+      }>
+      update: GInputObjectType<{
+        create?: GArg<GList<GNonNull<GraphQLTypesForList<ListTypeInfo>['create']>>>
+        connect: GArg<GList<GNonNull<GraphQLTypesForList<ListTypeInfo>['uniqueWhere']>>>
+        disconnect: GArg<GList<GNonNull<GraphQLTypesForList<ListTypeInfo>['uniqueWhere']>>>
+        set: GArg<GList<GNonNull<GraphQLTypesForList<ListTypeInfo>['uniqueWhere']>>>
+      }>
+    }
+  }
+}
+
+export type FindManyArgs = {
+  where: GArg<GNonNull<GraphQLTypesForList['where']>, true>
+  orderBy: GArg<GNonNull<GList<GNonNull<GraphQLTypesForList['orderBy']>>>, true>
+  take: GArg<typeof g.Int>
+  skip: GArg<GNonNull<typeof g.Int>, true>
+  cursor: GArg<GraphQLTypesForList['uniqueWhere']>
+}
+
+export type FindManyArgsValue = InferValueFromArgs<FindManyArgs>
+
+// fieldType(dbField)(fieldInfo) => { ...fieldInfo, dbField };
+export function fieldType<TDBField extends DBField, ListTypeInfo extends BaseListTypeInfo>(
+  dbField: TDBField
+) {
+  return function fieldTypeWrapper<
+    CreateArg extends GArg<GInputType> | undefined,
+    UpdateArg extends GArg<GInputType>,
+    UniqueWhereArg extends GArg<GNullableInputType, false>,
+    OrderByArg extends GArg<GNullableInputType, false>,
+    FilterArg extends GArg<GNullableInputType, false>,
+  >(
+    graphQLInfo: FieldTypeWithoutDBField<
+      TDBField,
+      CreateArg,
+      UpdateArg,
+      UniqueWhereArg,
+      OrderByArg,
+      FilterArg,
+      ListTypeInfo
+    >
+  ): NextFieldType<
+    DBField,
+    GArg<GInputType> | undefined,
+    GArg<GInputType>,
+    GArg<GNullableInputType, false>,
+    GArg<GNullableInputType, false>,
+    GArg<GNullableInputType, false>,
+    any
+  > {
+    return { ...graphQLInfo, dbField } as any
+  }
+}

package/src/types/prisma.ts

@@ -0,0 +1,16 @@
+export type PrismaFilter = Record<string, any> & {
+  _____?: 'prisma filter'
+  AND?: PrismaFilter[] | PrismaFilter
+  OR?: PrismaFilter[] | PrismaFilter
+  NOT?: PrismaFilter[] | PrismaFilter
+  // just so that if you pass an array to something expecting a PrismaFilter, you get an error
+  length?: undefined
+  // so that if you pass a promise, you get an error
+  then?: undefined
+}
+
+export type UniquePrismaFilter = Record<string, any> & {
+  _____?: 'unique prisma filter'
+  // so that if you pass a promise, you get an error
+  then?: undefined
+}

package/src/types/schema/g.ts

@@ -0,0 +1,5 @@
+import type { NixxieContext } from '../context'
+import { gWithContext } from './gWithContext'
+
+export const g = gWithContext<NixxieContext>()
+export type g<T> = gWithContext.infer<T>

package/src/types/schema/gWithContext.ts

@@ -0,0 +1,20 @@
+import type { GWithContext } from '@graphql-ts/schema'
+import { gWithContext as baseGWithContext } from '@graphql-ts/schema'
+import { extend } from '@graphql-ts/extend'
+import * as scalars from './scalars'
+import type { NixxieContext } from '../context'
+
+export function gWithContext<Context extends NixxieContext<any>>(): GWithContext<Context> &
+  typeof scalars & {
+    extend: typeof extend
+  } {
+  return {
+    ...baseGWithContext<Context>(),
+    ...scalars,
+    extend,
+  }
+}
+
+export declare namespace gWithContext {
+  export type infer<T> = baseGWithContext.infer<T>
+}

package/src/types/schema/index.ts

@@ -0,0 +1,4 @@
+export { g } from './g'
+export { gWithContext } from './gWithContext'
+// this must use export * to allow for easy use of "Rename Symbol" to update `graphql` to `g`
+export * from './legacy-alias'

package/src/types/schema/legacy-alias.d.ts

@@ -0,0 +1,28 @@
+import { g as _graphql } from './g'
+
+/**
+ * The `graphql` export has been renamed to `g`.
+ *
+ * To quickly update usages of `graphql` in your project to `g`:
+ *
+ * 1. Navigate to
+ *    `node_modules/@nixxie-cms/core/dist/declarations/src/types/schema/legacy-alias.d.ts`
+ *    in your editor ("Go to Definition" will not take you to the correct file)
+ * 2. Use "Rename Symbol" to rename `graphql` to `g`, this will update usages of
+ *    `graphql` to `g`
+ * 3. Change this deprecated alias back from `g` to `graphql` using normal text
+ *    editing (avoid using "Rename Symbol" again because you want to preserve
+ *    the updates you made in step 2)
+ *
+ * You can also use "Rename Symbol" to quickly rename your own custom defined
+ * `graphql` export to `g`.
+ *
+ * @deprecated
+ */
+// this is what you should run "Rename Symbol" on
+// when that is done, you should change it back to `export import graphql = _graphql;`
+// avoid using "Rename Symbol" to revert it because you want to
+// preserve the updates you made to the usages of `graphql`
+//            |||||||
+//            vvvvvvv
+export import graphql = _graphql

package/src/types/schema/legacy-alias.js

@@ -0,0 +1 @@
+export { g as graphql } from './g'