@nixxie-cms/core 1.0.0

package/src/lib/core/resolve-relationships.ts

@@ -0,0 +1,303 @@
+import type {
+  DBField,
+  MultiDBField,
+  NoDBField,
+  RelationDBField,
+  ScalarishDBField,
+} from '../../types'
+
+type BaseResolvedRelationDBField = {
+  kind: 'relation'
+  list: string
+  field: string
+  relationName: string
+  extendPrismaSchema?: (field: string) => string
+}
+
+export type ResolvedRelationDBField =
+  | (BaseResolvedRelationDBField & { mode: 'many' })
+  | (BaseResolvedRelationDBField & {
+      mode: 'one'
+      foreignIdField: { kind: 'none' } | { kind: 'owned' | 'owned-unique'; map: string }
+    })
+
+export type ListsWithResolvedRelations = Record<string, FieldsWithResolvedRelations>
+
+export type ResolvedDBField =
+  | ResolvedRelationDBField
+  | ScalarishDBField
+  | NoDBField
+  | MultiDBField<Record<string, ScalarishDBField>>
+
+// note: all nixxie fields correspond to a field here
+// not all fields here correspond to nixxie fields(the implicit side of one-sided relation fields)
+type FieldsWithResolvedRelations = Record<string, ResolvedDBField>
+
+type Rel = {
+  listKey: string
+  fieldPath: string
+  field: RelationDBField<'many' | 'one'>
+}
+
+type RelWithoutForeignKeyAndName = Omit<Rel, 'field'> & {
+  field: Omit<RelationDBField<'many' | 'one'>, 'foreignKey' | 'relationName'>
+}
+
+function sortRelationships(left: Rel, right: Rel): readonly [Rel, RelWithoutForeignKeyAndName] {
+  if (left.field.mode === 'one' && right.field.mode === 'one') {
+    if (left.field.foreignKey !== undefined && right.field.foreignKey !== undefined) {
+      throw new Error(
+        `You can only set db.foreignKey on one side of a one to one relationship, but foreignKey is set on both ${left.listKey}.${left.fieldPath} and ${right.listKey}.${right.fieldPath}`
+      )
+    }
+
+    // return the field that specifies the foreignKey first
+    if (left.field.foreignKey) return [left, right]
+    if (right.field.foreignKey) return [right, left]
+  } else if (left.field.mode === 'one' || right.field.mode === 'one') {
+    // many relationships will never have a foreign key, so return the one relationship first
+    const rels = left.field.mode === 'one' ? ([left, right] as const) : ([right, left] as const)
+    // we're only doing this for rels[1] because:
+    // - rels[1] is the many side
+    // - for the one side, TypeScript will already disallow relationName
+    if (rels[1].field.relationName !== undefined)
+      throw new Error(
+        `You can only set db.relationName on one side of a many to many relationship, but db.relationName is set on ${rels[1].listKey}.${rels[1].fieldPath} which is the many side of a many to one relationship with ${rels[0].listKey}.${rels[0].fieldPath}`
+      )
+    return rels
+  }
+  if (
+    left.field.mode === 'many' &&
+    right.field.mode === 'many' &&
+    (left.field.relationName !== undefined || right.field.relationName !== undefined)
+  ) {
+    if (left.field.relationName !== undefined && right.field.relationName !== undefined) {
+      throw new Error(
+        `You can only set db.relationName on one side of a many to many relationship, but db.relationName is set on both ${left.listKey}.${left.fieldPath} and ${right.listKey}.${right.fieldPath}`
+      )
+    }
+    return left.field.relationName !== undefined ? [left, right] : [right, left]
+  }
+
+  const order = left.listKey.localeCompare(right.listKey)
+
+  if (order > 0) return [right, left] // left comes after right, so swap them
+  if (order === 0) {
+    // self referential list, so check the paths.
+    if (left.fieldPath.localeCompare(right.fieldPath) > 0) {
+      return [right, left]
+    }
+  }
+
+  return [left, right]
+}
+
+// what's going on here:
+// - validating all the relationships
+// - for relationships involving to-one: deciding which side owns the foreign key
+// - turning one-sided relationships into two-sided relationships so that elsewhere in Nixxie,
+//   you only have to reason about two-sided relationships
+//   (note that this means that there are "fields" in the returned ListsWithResolvedRelations
+//   which are not actually proper Nixxie fields, they are just a db field and nothing else)
+export function resolveRelationships(
+  lists: Record<string, { fields: Record<string, { dbField: DBField }>; isSingleton: boolean }>
+): ListsWithResolvedRelations {
+  const alreadyResolvedTwoSidedRelationships = new Set<string>()
+  const resolvedLists: Record<string, Record<string, ResolvedDBField>> = Object.fromEntries(
+    Object.keys(lists).map(listKey => [listKey, {}])
+  )
+  for (const [listKey, fields] of Object.entries(lists)) {
+    const resolvedList = resolvedLists[listKey]
+    for (const [fieldPath, { dbField: field }] of Object.entries(fields.fields)) {
+      if (field.kind !== 'relation') {
+        resolvedList[fieldPath] = field
+        continue
+      }
+      const foreignUnresolvedList = lists[field.list]
+      if (!foreignUnresolvedList) {
+        throw new Error(
+          `The relationship field at ${listKey}.${fieldPath} points to the list ${listKey} which does not exist`
+        )
+      }
+      if (foreignUnresolvedList.isSingleton) {
+        throw new Error(
+          `The relationship field at ${listKey}.${fieldPath} points to a singleton list, ${listKey}, which is not allowed`
+        )
+      }
+      if (field.field) {
+        const localRef = `${listKey}.${fieldPath}`
+        const foreignRef = `${field.list}.${field.field}`
+        if (alreadyResolvedTwoSidedRelationships.has(localRef)) continue
+
+        alreadyResolvedTwoSidedRelationships.add(foreignRef)
+        const foreignField = foreignUnresolvedList.fields[field.field]?.dbField
+        if (!foreignField)
+          throw new Error(`${localRef} points to ${foreignRef}, but ${foreignRef} doesn't exist`)
+
+        if (foreignField.kind !== 'relation') {
+          throw new Error(
+            `${localRef} points to ${foreignRef}, but ${foreignRef} is not a relationship field`
+          )
+        }
+
+        const actualRef = foreignField.field
+          ? `${foreignField.list}.${foreignField.field}`
+          : foreignField.list
+        if (actualRef !== localRef) {
+          throw new Error(
+            `${localRef} expects ${foreignRef} to be a two way relationship, but ${foreignRef} points to ${actualRef}`
+          )
+        }
+
+        const [leftRel, rightRel] = sortRelationships(
+          { listKey, fieldPath, field },
+          { listKey: field.list, fieldPath: field.field, field: foreignField }
+        )
+
+        if (leftRel.field.mode === 'one' && rightRel.field.mode === 'one') {
+          const relationName = `${leftRel.listKey}_${leftRel.fieldPath}`
+          resolvedLists[leftRel.listKey][leftRel.fieldPath] = {
+            kind: 'relation',
+            mode: 'one',
+            field: rightRel.fieldPath,
+            list: rightRel.listKey,
+            extendPrismaSchema: leftRel.field.extendPrismaSchema,
+            foreignIdField: {
+              kind: 'owned-unique',
+              map:
+                typeof leftRel.field.foreignKey === 'object'
+                  ? leftRel.field.foreignKey?.map
+                  : leftRel.fieldPath,
+            },
+            relationName,
+          }
+          resolvedLists[rightRel.listKey][rightRel.fieldPath] = {
+            kind: 'relation',
+            mode: 'one',
+            field: leftRel.fieldPath,
+            list: leftRel.listKey,
+            extendPrismaSchema: rightRel.field.extendPrismaSchema,
+            foreignIdField: { kind: 'none' },
+            relationName,
+          }
+          continue
+        }
+
+        if (leftRel.field.mode === 'many' && rightRel.field.mode === 'many') {
+          const relationName =
+            leftRel.field.relationName ?? `${leftRel.listKey}_${leftRel.fieldPath}`
+          resolvedLists[leftRel.listKey][leftRel.fieldPath] = {
+            kind: 'relation',
+            mode: 'many',
+            extendPrismaSchema: leftRel.field.extendPrismaSchema,
+            field: rightRel.fieldPath,
+            list: rightRel.listKey,
+            relationName,
+          }
+          resolvedLists[rightRel.listKey][rightRel.fieldPath] = {
+            kind: 'relation',
+            mode: 'many',
+            extendPrismaSchema: rightRel.field.extendPrismaSchema,
+            field: leftRel.fieldPath,
+            list: leftRel.listKey,
+            relationName,
+          }
+          continue
+        }
+
+        const relationName = `${leftRel.listKey}_${leftRel.fieldPath}`
+        resolvedLists[leftRel.listKey][leftRel.fieldPath] = {
+          kind: 'relation',
+          mode: 'one',
+          field: rightRel.fieldPath,
+          extendPrismaSchema: leftRel.field.extendPrismaSchema,
+          list: rightRel.listKey,
+          foreignIdField: {
+            kind: 'owned',
+            map:
+              typeof leftRel.field.foreignKey === 'object'
+                ? leftRel.field.foreignKey?.map
+                : leftRel.fieldPath,
+          },
+          relationName,
+        }
+
+        resolvedLists[rightRel.listKey][rightRel.fieldPath] = {
+          kind: 'relation',
+          mode: 'many',
+          extendPrismaSchema: rightRel.field.extendPrismaSchema,
+          field: leftRel.fieldPath,
+          list: leftRel.listKey,
+          relationName,
+        }
+        continue
+      }
+
+      const foreignFieldPath = `from_${listKey}_${fieldPath}`
+      if (foreignUnresolvedList.fields[foreignFieldPath]) {
+        throw new Error(
+          `The relationship field at ${listKey}.${fieldPath} points to the list ${field.list}, Nixxie needs to a create a relationship field at ${field.list}.${foreignFieldPath} to support the relationship at ${listKey}.${fieldPath} but ${field.list} already has a field named ${foreignFieldPath}`
+        )
+      }
+
+      if (field.mode === 'many') {
+        const relationName = field.relationName ?? `${listKey}_${fieldPath}`
+        resolvedLists[field.list][foreignFieldPath] = {
+          kind: 'relation',
+          mode: 'many',
+          extendPrismaSchema: field.extendPrismaSchema,
+          list: listKey,
+          field: fieldPath,
+          relationName,
+        }
+        resolvedList[fieldPath] = {
+          kind: 'relation',
+          mode: 'many',
+          extendPrismaSchema: field.extendPrismaSchema,
+          list: field.list,
+          field: foreignFieldPath,
+          relationName,
+        }
+      } else {
+        const relationName = `${listKey}_${fieldPath}`
+        resolvedLists[field.list][foreignFieldPath] = {
+          kind: 'relation',
+          mode: 'many',
+          extendPrismaSchema: field.extendPrismaSchema,
+          list: listKey,
+          field: fieldPath,
+          relationName,
+        }
+        resolvedList[fieldPath] = {
+          kind: 'relation',
+          list: field.list,
+          extendPrismaSchema: field.extendPrismaSchema,
+          field: foreignFieldPath,
+          foreignIdField: {
+            kind: 'owned',
+            map: typeof field.foreignKey === 'object' ? field.foreignKey?.map : fieldPath,
+          },
+          relationName,
+          mode: 'one',
+        }
+      }
+    }
+  }
+
+  // the way we resolve the relationships means that the relationships will be in a
+  // different order than the order the user specified in their config
+  // doesn't really change the behaviour of anything but it means that the order of the fields in the prisma schema will be
+  // the same as the user provided
+  return Object.fromEntries(
+    Object.entries(resolvedLists).map(([listKey, outOfOrderDbFields]) => {
+      // this adds the fields based on the order that the user passed in
+      // (except it will not add the opposites to one-sided relations)
+      const resolvedDbFields = Object.fromEntries(
+        Object.keys(lists[listKey].fields).map(fieldKey => [fieldKey, outOfOrderDbFields[fieldKey]])
+      )
+      // then we add the opposites to one-sided relations
+      Object.assign(resolvedDbFields, outOfOrderDbFields)
+      return [listKey, resolvedDbFields]
+    })
+  )
+}

package/src/lib/core/utils.ts

@@ -0,0 +1,56 @@
+// this is wrong
+// all the things should be generic over the id type
+// i don't want to deal with that right now though
+declare const idTypeSymbol: unique symbol
+
+export type IdType = { ___nixxieIdType: typeof idTypeSymbol; toString(): string }
+
+// these aren't here out of thinking this is better syntax(i do not think it is),
+// it's just because TS won't infer the arg is X bit
+export const isFulfilled = <T>(arg: PromiseSettledResult<T>): arg is PromiseFulfilledResult<T> =>
+  arg.status === 'fulfilled'
+export const isRejected = (arg: PromiseSettledResult<any>): arg is PromiseRejectedResult =>
+  arg.status === 'rejected'
+
+export async function promiseAllRejectWithAllErrors<T extends unknown[]>(
+  promises: readonly [...T]
+): Promise<{ [P in keyof T]: Awaited<T[P]> }> {
+  const results = await Promise.allSettled(promises)
+  if (!results.every(isFulfilled)) {
+    const errors = results.filter(isRejected).map(x => x.reason)
+    // AggregateError would be ideal here but it's not in Node 12 or 14
+    // (also all of our error stuff is just meh. this whole thing is just to align with previous behaviour)
+    const error = new Error(errors[0].message || errors[0].toString())
+    ;(error as any).errors = errors
+    throw error
+  }
+
+  return results.map((x: any) => x.value) as any
+}
+
+export function getDBFieldKeyForFieldOnMultiField(fieldKey: string, subField: string) {
+  return `${fieldKey}_${subField}`
+}
+
+export function areArraysEqual(a: readonly unknown[], b: readonly unknown[]) {
+  return a.length === b.length && a.every((x, i) => x === b[i])
+}
+
+export function weakMemoize<Arg extends object, Return>(cb: (arg: Arg) => Return) {
+  const cache = new WeakMap<Arg, Return>()
+  return (arg: Arg) => {
+    if (!cache.has(arg)) {
+      const result = cb(arg)
+      cache.set(arg, result)
+    }
+    return cache.get(arg)!
+  }
+}
+
+export function entriesTyped<T extends Record<string, unknown>>(
+  obj: T
+): {
+  [K in keyof T]: [K, T[K]]
+}[keyof T][] {
+  return Object.entries(obj) as any
+}

package/src/lib/core/where-inputs.ts

@@ -0,0 +1,130 @@
+import { type DBField, type NixxieContext } from '../../types'
+import { type PrismaFilter, type UniquePrismaFilter } from '../../types/prisma'
+import { userInputError } from './graphql-errors'
+import { type InitialisedList } from './initialise-lists'
+import { getDBFieldKeyForFieldOnMultiField } from './utils'
+
+export type InputFilter = Record<string, any> & {
+  _____?: 'input filter'
+  AND?: InputFilter[]
+  OR?: InputFilter[]
+  NOT?: InputFilter[]
+}
+
+export type UniqueInputFilter = Record<string, any> & { _____?: 'unique input filter' }
+
+export async function resolveUniqueWhereInput(
+  inputFilter: UniqueInputFilter,
+  list: InitialisedList,
+  context: NixxieContext
+): Promise<UniquePrismaFilter> {
+  const where: UniquePrismaFilter = {}
+  for (const key in inputFilter) {
+    const value = inputFilter[key]
+
+    const resolver = list.fields[key].input!.uniqueWhere!.resolve
+    if (resolver !== undefined) {
+      where[key] = await resolver(value, context)
+    } else {
+      where[key] = value
+    }
+  }
+
+  return where
+}
+
+export async function resolveWhereInput(
+  inputFilter: InputFilter,
+  list: InitialisedList,
+  context: NixxieContext
+): Promise<PrismaFilter> {
+  return {
+    AND: await Promise.all(
+      Object.entries(inputFilter).map(async ([key, value]) => {
+        if (key === 'OR' || key === 'AND' || key === 'NOT') {
+          return {
+            [key]: await Promise.all(
+              value.map((value: any) => resolveWhereInput(value, list, context))
+            ),
+          }
+        }
+
+        // we know if there are filters in the input object with the key of a field,
+        //   the field must have defined a where input so this non null assertion is okay
+        const field = list.fields[key]
+        const { dbField } = field
+
+        const resolve = field.input!.where!.resolve
+        const ret = resolve
+          ? await resolve(
+              value,
+              context,
+              (() => {
+                if (dbField.kind !== 'relation') {
+                  return undefined as any
+                }
+                const foreignList = dbField.list
+                const whereResolver = (filter: InputFilter) =>
+                  resolveWhereInput(filter, list.lists[foreignList], context)
+
+                if (dbField.mode === 'many') {
+                  return async () => {
+                    if (value === null) {
+                      throw userInputError('A many relation filter cannot be set to null')
+                    }
+                    return Object.fromEntries(
+                      await Promise.all(
+                        Object.entries(value).map(async ([key, val]) => {
+                          if (val === null) {
+                            throw userInputError(
+                              `The key "${key}" in a many relation filter cannot be set to null`
+                            )
+                          }
+                          return [key, await whereResolver(val as any)]
+                        })
+                      )
+                    )
+                  }
+                }
+
+                return (value: any) => {
+                  if (value === null) return null
+                  return whereResolver(value)
+                }
+              })()
+            )
+          : value
+        if (ret === null) {
+          if (dbField.kind === 'multi') {
+            // Note: no built-in field types support multi valued database fields *and* filtering.
+            // This code path is only relevent to custom fields which fit that criteria.
+            throw new Error('multi db fields cannot return null from where input resolvers')
+          }
+          return { [key]: null }
+        }
+        return handleOperators(key, dbField, ret)
+      })
+    ),
+  }
+}
+
+function handleOperators(fieldKey: string, dbField: DBField, { AND, OR, NOT, ...rest }: any) {
+  return {
+    AND: AND?.map((value: any) => handleOperators(fieldKey, dbField, value)),
+    OR: OR?.map((value: any) => handleOperators(fieldKey, dbField, value)),
+    NOT: NOT?.map((value: any) => handleOperators(fieldKey, dbField, value)),
+    ...nestWithAppropiateField(fieldKey, dbField, rest),
+  }
+}
+
+function nestWithAppropiateField(fieldKey: string, dbField: DBField, value: any) {
+  if (dbField.kind === 'multi') {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, val]) => [
+        getDBFieldKeyForFieldOnMultiField(fieldKey, key),
+        val,
+      ])
+    )
+  }
+  return { [fieldKey]: value }
+}

package/src/lib/express.ts

@@ -0,0 +1,109 @@
+import { type Server, createServer } from 'http'
+import cors from 'cors'
+import { json } from 'body-parser'
+import { expressMiddleware } from '@apollo/server/express4'
+import express from 'express'
+import { GraphQLError, type GraphQLFormattedError } from 'graphql'
+import { type ApolloServerOptions, ApolloServer } from '@apollo/server'
+import { ApolloServerPluginLandingPageDisabled } from '@apollo/server/plugin/disabled'
+import { ApolloServerPluginLandingPageLocalDefault } from '@apollo/server/plugin/landingPage/default'
+// @ts-expect-error
+import graphqlUploadExpress from 'graphql-upload/graphqlUploadExpress.js'
+import type { NixxieContext, NixxieConfig } from '../types'
+
+/*
+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: NixxieConfig['graphql']) {
+  let debug = graphqlConfig.debug
+  if (debug === undefined) {
+    debug = process.env.NODE_ENV !== 'production'
+  }
+  return (formattedError: GraphQLFormattedError, error: unknown) => {
+    if (error instanceof GraphQLError && 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.apolloConfig?.formatError) {
+      return graphqlConfig.apolloConfig.formatError(formattedError, error)
+    }
+
+    return formattedError
+  }
+}
+
+export async function createExpressServer(
+  config: Pick<NixxieConfig, 'graphql' | 'server'>,
+  context: NixxieContext
+): Promise<{
+  expressServer: express.Express
+  apolloServer: ApolloServer<NixxieContext>
+  httpServer: Server
+}> {
+  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?.plugins
+        : [
+            config.graphql.playground
+              ? ApolloServerPluginLandingPageLocalDefault()
+              : ApolloServerPluginLandingPageDisabled(),
+            ...(apolloConfig?.plugins ?? []),
+          ],
+  } as ApolloServerOptions<NixxieContext> // 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) => {
+      // WARNING: body-parser@^2 only sets .body if a .body is parsed, Apollo always wants .body to be set
+      req.body ??= {}
+      next()
+    },
+    expressMiddleware(apolloServer, {
+      context: async ({ req, res }) => {
+        return await context.withRequest(req, res)
+      },
+    })
+  )
+
+  return { expressServer, apolloServer, httpServer }
+}

package/src/lib/graphql.ts

@@ -0,0 +1,83 @@
+import type { GField, GOutputType } from '@graphql-ts/schema'
+import { type GraphQLNamedType, GraphQLSchema } from 'graphql'
+
+import type { NixxieConfig, NixxieContext } from '../types'
+import { g } from '../types/schema'
+import type { AdminMetaSource } from './admin-meta'
+import { NixxieMeta } from './admin-meta-graphql'
+import type { InitialisedList } from './core/initialise-lists'
+import { getMutationsForList } from './core/mutations'
+import { getQueriesForList } from './core/queries'
+
+function getGraphQLSchema(
+  lists: Record<string, InitialisedList>,
+  extraFields: {
+    query: Record<
+      string,
+      GField<unknown, any, GOutputType<NixxieContext>, unknown, NixxieContext>
+    >
+    mutation: Record<
+      string,
+      GField<unknown, any, GOutputType<NixxieContext>, unknown, NixxieContext>
+    >
+  },
+  sudo: boolean
+) {
+  const query = g.object()({
+    name: 'Query',
+    fields: Object.assign(
+      {},
+      ...Object.values(lists).map(list => getQueriesForList(list)),
+      extraFields.query
+    ),
+  })
+
+  const collectedTypes: GraphQLNamedType[] = []
+  const mutation = g.object()({
+    name: 'Mutation',
+    fields: Object.assign(
+      {},
+      ...Object.values(lists).map(list => {
+        const { mutations, types } = getMutationsForList(list)
+        collectedTypes.push(...types)
+        return mutations
+      }),
+      extraFields.mutation
+    ),
+  })
+
+  return new GraphQLSchema({
+    query,
+    mutation,
+    types: [...collectedTypes, g.JSON, mutation],
+    extensions: {
+      sudo,
+    },
+  })
+}
+
+export function createGraphQLSchema(
+  config: NixxieConfig,
+  lists: Record<string, InitialisedList>,
+  adminMeta: AdminMetaSource | null,
+  sudo: boolean
+) {
+  const graphQLSchema = getGraphQLSchema(
+    lists,
+    {
+      mutation: {},
+      query: adminMeta
+        ? {
+            nixxie: g.field({
+              type: g.nonNull(NixxieMeta),
+              resolve: () => ({ adminMeta }),
+            }),
+          }
+        : {},
+    },
+    sudo
+  )
+
+  // merge in the user defined graphQL API
+  return config.graphql?.extendGraphqlSchema?.(graphQLSchema) ?? graphQLSchema
+}