@nixxie-cms/core 1.0.0

package/src/types/schema/scalars.ts

@@ -0,0 +1,220 @@
+import type { ReadStream } from 'node:fs'
+// @ts-expect-error
+import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
+import { GraphQLError, GraphQLScalarType } from 'graphql'
+import { Decimal as DecimalValue } from 'decimal.js'
+import type { JSONValue } from '../utils'
+
+export const JSON = new GraphQLScalarType<JSONValue>({
+  name: 'JSON',
+  description:
+    'The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf).',
+  specifiedByURL: 'http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf',
+  // the defaults for serialize, parseValue and parseLiteral do what makes sense for JSON
+})
+
+// avoiding using Buffer.from/etc. because we want a plain Uint8Array and that would be an extra conversion
+// when https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array/toHex and etc.
+// is available we should use that instead
+
+function hexToBytes(value: string): Uint8Array {
+  if (!/^[0-9a-fA-F]*$/.test(value)) {
+    throw new GraphQLError('Hex values must be a string of hexadecimal characters')
+  }
+  if (value.length % 2 !== 0) {
+    throw new GraphQLError('Hex values must have an even number of characters')
+  }
+  const bytes = new Uint8Array(value.length / 2)
+  for (let i = 0; i < bytes.byteLength; i += 1) {
+    const start = i * 2
+    bytes[i] = parseInt(value.slice(start, start + 2), 16)
+  }
+  return bytes
+}
+
+function bytesToHex(bytes: Uint8Array): string {
+  let str = ''
+  for (const byte of bytes) {
+    str += byte.toString(16).padStart(2, '0')
+  }
+  return str
+}
+
+export const Hex = new GraphQLScalarType({
+  name: 'Hex',
+  description: 'The `Hex` scalar type represents bytes as a string of hexadecimal characters.',
+  parseLiteral(value) {
+    if (value.kind !== 'StringValue') {
+      throw new GraphQLError('Hex only accepts values as strings')
+    }
+    return hexToBytes(value.value)
+  },
+  parseValue(value) {
+    // so that when you're doing a mutation in a resolver, you can just pass in a Uint8Array directly
+    if (value instanceof Uint8Array) {
+      // duplicate it though to avoid any weirdness with the array being mutated
+      // + ensuring that if you pass in a Buffer, resolvers receive a normal Uint8Array
+      return Uint8Array.from(value)
+    }
+    if (typeof value !== 'string') {
+      throw new GraphQLError('Hex only accepts values as strings')
+    }
+    return hexToBytes(value)
+  },
+  serialize(value) {
+    if (!(value instanceof Uint8Array)) {
+      throw new GraphQLError(`unexpected value provided to Hex scalar: ${value}`)
+    }
+    return bytesToHex(value)
+  },
+})
+
+type FileUpload = {
+  filename: string
+  mimetype: string
+  encoding: string
+  createReadStream(): ReadStream
+}
+
+export const Upload: GraphQLScalarType<Promise<FileUpload>, {}> = GraphQLUpload
+
+// - Decimal.js throws on invalid inputs
+// - Decimal.js can represent +Infinity and -Infinity, these aren't values in Postgres' decimal,
+//   NaN is but Prisma doesn't support it
+//   .isFinite refers to +Infinity, -Infinity and NaN
+export const Decimal = new GraphQLScalarType<DecimalValue & { scaleToPrint?: number }, string>({
+  name: 'Decimal',
+  serialize(value) {
+    if (!DecimalValue.isDecimal(value))
+      throw new GraphQLError(`unexpected value provided to Decimal scalar: ${value}`)
+    const cast = value as DecimalValue & { scaleToPrint?: number }
+    if (cast.scaleToPrint !== undefined) return value.toFixed(cast.scaleToPrint)
+    return value.toString()
+  },
+  parseLiteral(value) {
+    if (value.kind !== 'StringValue')
+      throw new GraphQLError('Decimal only accepts values as strings')
+    const decimal = new DecimalValue(value.value)
+    if (!decimal.isFinite()) throw new GraphQLError('Decimal values must be finite')
+    return decimal
+  },
+  parseValue(value) {
+    if (DecimalValue.isDecimal(value)) {
+      if (!value.isFinite()) throw new GraphQLError('Decimal values must be finite')
+      return value
+    }
+    if (typeof value !== 'string') throw new GraphQLError('Decimal only accepts values as strings')
+    const decimal = new DecimalValue(value)
+    if (!decimal.isFinite()) throw new GraphQLError('Decimal values must be finite')
+    return decimal
+  },
+})
+
+export const BigInt = new GraphQLScalarType({
+  name: 'BigInt',
+  serialize(value) {
+    if (typeof value !== 'bigint')
+      throw new GraphQLError(`unexpected value provided to BigInt scalar: ${value}`)
+    return value.toString()
+  },
+  parseLiteral(value) {
+    if (value.kind !== 'StringValue')
+      throw new GraphQLError('BigInt only accepts values as strings')
+    return globalThis.BigInt(value.value)
+  },
+  parseValue(value) {
+    if (typeof value === 'bigint') return value
+    if (typeof value !== 'string') throw new GraphQLError('BigInt only accepts values as strings')
+    return globalThis.BigInt(value)
+  },
+})
+
+// from https://github.com/excitement-engineer/graphql-iso-date/blob/master/src/utils/validator.js#L121
+// this is also what prisma uses https://github.com/prisma/prisma/blob/20b58fe65d581bcb43c0d5c28d4b89cabc2d99b2/packages/client/src/runtime/utils/common.ts#L126-L128
+const RFC_3339_REGEX =
+  /^(\d{4}-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])T([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9]|60))(\.\d{1,})?(([Z])|([+|-]([01][0-9]|2[0-3]):[0-5][0-9]))$/
+
+function parseDate(input: string): Date {
+  if (!RFC_3339_REGEX.test(input)) {
+    throw new GraphQLError(
+      'DateTime scalars must be in the form of a full ISO 8601 date-time string'
+    )
+  }
+  const parsed = new Date(input)
+  if (isNaN(parsed.valueOf())) {
+    throw new GraphQLError(
+      'DateTime scalars must be in the form of a full ISO 8601 date-time string'
+    )
+  }
+  return parsed
+}
+
+export const DateTime = new GraphQLScalarType({
+  name: 'DateTime',
+  specifiedByURL: 'https://datatracker.ietf.org/doc/html/rfc3339#section-5.6',
+  serialize(value: unknown) {
+    if (!(value instanceof Date) || isNaN(value.valueOf())) {
+      throw new GraphQLError(`unexpected value provided to DateTime scalar: ${value}`)
+    }
+    return value.toISOString()
+  },
+  parseLiteral(value) {
+    if (value.kind !== 'StringValue') {
+      throw new GraphQLError('DateTime only accepts values as strings')
+    }
+    return parseDate(value.value)
+  },
+  parseValue(value: unknown) {
+    if (value instanceof Date) return value
+    if (typeof value !== 'string') {
+      throw new GraphQLError('DateTime only accepts values as strings')
+    }
+    return parseDate(value)
+  },
+})
+
+const RFC_3339_FULL_DATE_REGEX = /^\d{4}-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])$/
+
+function validateCalendarDay(input: string) {
+  if (!RFC_3339_FULL_DATE_REGEX.test(input)) {
+    throw new GraphQLError('CalendarDay scalars must be in the form of a full-date ISO 8601 string')
+  }
+}
+
+export const CalendarDay = new GraphQLScalarType({
+  name: 'CalendarDay',
+  specifiedByURL: 'https://datatracker.ietf.org/doc/html/rfc3339#section-5.6',
+  serialize(value: unknown) {
+    if (typeof value !== 'string') {
+      throw new GraphQLError(`unexpected value provided to CalendarDay scalar: ${value}`)
+    }
+    return value
+  },
+  parseLiteral(value) {
+    if (value.kind !== 'StringValue') {
+      throw new GraphQLError('CalendarDay only accepts values as strings')
+    }
+    validateCalendarDay(value.value)
+    return value.value
+  },
+  parseValue(value: unknown) {
+    if (typeof value !== 'string') {
+      throw new GraphQLError('CalendarDay only accepts values as strings')
+    }
+    validateCalendarDay(value)
+    return value
+  },
+})
+
+export const Empty = new GraphQLScalarType({
+  name: 'Empty',
+  serialize(value) {
+    return null
+  },
+  parseLiteral(value) {
+    return {}
+  },
+  parseValue(value) {
+    return {}
+  },
+})

package/src/types/session.ts

@@ -0,0 +1,26 @@
+import type { MaybePromise } from './utils'
+import type { BaseNixxieTypeInfo, NixxieContext } from '.'
+
+export type SessionStrategy<
+  Session,
+  TypeInfo extends BaseNixxieTypeInfo = BaseNixxieTypeInfo,
+> = {
+  get: (args: { context: NixxieContext<TypeInfo> }) => Promise<Session | undefined>
+  start: (args: { context: NixxieContext<TypeInfo>; data: Session }) => Promise<unknown>
+  end: (args: { context: NixxieContext<TypeInfo> }) => Promise<unknown>
+}
+
+/** @deprecated */
+export type SessionStore<Session> = {
+  get(key: string): MaybePromise<Session | undefined>
+  set(key: string, value: Session): void | Promise<void>
+  delete(key: string): void | Promise<void>
+}
+
+/** @deprecated */
+export type SessionStoreFunction<Session> = (args: {
+  /**
+   * The number of seconds that a cookie session be valid for
+   */
+  maxAge: number
+}) => SessionStore<Session>

package/src/types/telemetry.ts

@@ -0,0 +1,51 @@
+import type { DatabaseProvider } from './core'
+
+export type TelemetryVersion1 =
+  | undefined
+  | false
+  | {
+      device: { lastSentDate?: string; informedAt: string }
+      projects: {
+        default: { lastSentDate?: string; informedAt: string }
+        [projectPath: string]: { lastSentDate?: string; informedAt: string }
+      }
+    }
+
+export type TelemetryVersion2 =
+  | undefined
+  | false
+  | {
+      informedAt: string | null
+      device: {
+        lastSentDate: string | null
+      }
+      projects: Partial<{
+        [projectPath: string]: {
+          lastSentDate: string
+        }
+      }>
+    }
+
+export type Device = {
+  lastSentDate: string | null // new Date().toISOString().slice(0, 10)
+  os: string // `linux` | `darwin` | `windows` | ... // os.platform()
+  node: string // `14` | ... | `18` // process.version.split('.').shift().slice(1)
+}
+
+export type Project = {
+  lastSentDate: string | null // new Date().toISOString().slice(0, 10)
+  // omitted uuid for <BII
+  // omitted anything GraphQL related <BII
+
+  // filtered to packages with the prefixes
+  // - `@nixxie`
+  // - `@opensaas`
+  // - ...
+  packages: Partial<Record<string, string>>
+  database: DatabaseProvider
+  lists: number
+  fields: {
+    // uses `field.__ksTelemetryFieldTypeName`, default is `unknown`
+    [key: string]: number
+  }
+}

package/src/types/type-info.ts

@@ -0,0 +1,38 @@
+import type { BaseItem } from './next-fields'
+import type { NixxieContext } from '../types'
+
+type GraphQLInput = Record<string, any>
+
+export type BaseListTypeInfo<Session = any> = {
+  key: string
+  fields: string
+  actions: string
+  item: BaseItem
+  inputs: {
+    create: GraphQLInput
+    update: GraphQLInput
+    where: GraphQLInput
+    uniqueWhere: { readonly id?: string | number | null } & GraphQLInput
+    orderBy: Record<string, 'asc' | 'desc' | null>
+  }
+
+  /**
+   * WARNING: may change in patch
+   */
+  prisma: {
+    create: Record<string, any>
+    update: Record<string, any>
+  }
+  all: BaseNixxieTypeInfo<Session>
+
+  isSingleton: boolean
+}
+
+export type NixxieContextFromListTypeInfo<ListTypeInfo extends BaseListTypeInfo> =
+  NixxieContext<ListTypeInfo['all']>
+
+export type BaseNixxieTypeInfo<Session = any> = {
+  lists: Record<string, BaseListTypeInfo<Session>>
+  prisma: any
+  session: Session
+}

package/src/types/type-tests.ts

@@ -0,0 +1,21 @@
+import type { NixxieContext } from './context'
+import type { BaseListTypeInfo } from './type-info'
+
+const someContext: NixxieContext<{
+  lists: {
+    Singleton: BaseListTypeInfo & { isSingleton: true }
+    List: BaseListTypeInfo & { isSingleton: false }
+    ListOrSingleton: BaseListTypeInfo
+  }
+  prisma: any
+  session: any
+}> = undefined!
+
+someContext.query.Singleton.findOne({})
+someContext.query.Singleton.findOne({ where: { id: '1' } })
+// @ts-expect-error
+someContext.query.List.findOne({})
+someContext.query.List.findOne({ where: { id: '1' } })
+// @ts-expect-error
+someContext.query.ListOrSingleton.findOne({})
+someContext.query.ListOrSingleton.findOne({ where: { id: '1' } })

package/src/types/utils.ts

@@ -0,0 +1,108 @@
+import pluralize from 'pluralize'
+import type { BaseNixxieTypeInfo, NixxieConfig, NixxieContext } from '../types'
+import type { Readable } from 'node:stream'
+import { humanize } from '../lib/utils'
+
+export type JSONValue =
+  | string
+  | number
+  | boolean
+  | undefined
+  | null
+  | readonly JSONValue[]
+  | { [key: string]: JSONValue }
+
+export type MaybePromise<T> = T | Promise<T>
+
+// WARNING: may break in patch
+export type GraphQLNames = ReturnType<typeof getGqlNames>
+
+export function getGqlNames({ singular, plural }: { singular: string; plural: string }) {
+  const lowerSingularName = singular.charAt(0).toLowerCase() + singular.slice(1)
+  const lowerPluralName = plural.charAt(0).toLowerCase() + plural.slice(1)
+  return {
+    outputTypeNameLower: lowerSingularName,
+    outputTypeName: singular,
+    whereInputName: `${singular}WhereInput`,
+    whereUniqueInputName: `${singular}WhereUniqueInput`,
+
+    // create
+    createInputName: `${singular}CreateInput`,
+    createMutationName: `create${singular}`,
+    createManyMutationName: `create${plural}`,
+    relateToOneForCreateInputName: `${singular}RelateToOneForCreateInput`,
+    relateToManyForCreateInputName: `${singular}RelateToManyForCreateInput`,
+
+    // read
+    itemQueryName: lowerSingularName,
+    listQueryName: lowerPluralName,
+    listQueryCountName: `${lowerPluralName}Count`,
+    listOrderName: `${singular}OrderByInput`,
+
+    // update
+    updateInputName: `${singular}UpdateInput`,
+    updateMutationName: `update${singular}`,
+    updateManyInputName: `${singular}UpdateArgs`,
+    updateManyMutationName: `update${plural}`,
+    relateToOneForUpdateInputName: `${singular}RelateToOneForUpdateInput`,
+    relateToManyForUpdateInputName: `${singular}RelateToManyForUpdateInput`,
+
+    // delete
+    deleteMutationName: `delete${singular}`,
+    deleteManyMutationName: `delete${plural}`,
+  }
+}
+
+const labelToPath = (str: string) => str.split(' ').join('-').toLowerCase()
+const labelToClass = (str: string) => str.replace(/\s+/g, '')
+
+// WARNING: may break in patch
+export function __getNames(listKey: string, list: NixxieConfig['lists'][string]) {
+  const { graphql, ui, isSingleton } = list
+  if (ui?.path !== undefined && !/^[a-z-_][a-z0-9-_]*$/.test(ui.path)) {
+    throw new Error(
+      `ui.path for ${listKey} is ${ui.path} but it must only contain lowercase letters, numbers, dashes, and underscores and not start with a number`
+    )
+  }
+
+  const singular = listKey // an assumption
+  const plural = pluralize.plural(singular)
+
+  const graphqlSingular = graphql?.singular || labelToClass(singular)
+  const graphqlPlural = graphql?.plural || labelToClass(plural)
+  if (graphqlSingular === graphqlPlural) {
+    throw new Error(
+      `The singular and plural name used by GraphQL must be different, but ${graphqlSingular} is the same as ${graphqlPlural}`
+    )
+  }
+
+  return {
+    graphql: {
+      singular: graphqlSingular,
+      plural: graphqlPlural,
+      names: getGqlNames({
+        singular: graphqlSingular,
+        plural: graphqlPlural,
+      }),
+    },
+    ui: {
+      labels: {
+        label: ui?.label || humanize(isSingleton ? singular : plural),
+        singular: ui?.singular || humanize(singular),
+        plural: ui?.plural || humanize(plural),
+        path: ui?.path || labelToPath(humanize(isSingleton ? singular : plural)),
+      },
+    },
+  }
+}
+
+export type StorageStrategy<TypeInfo extends BaseNixxieTypeInfo> = {
+  put(
+    key: string,
+    stream: Readable,
+    meta: { contentType: string },
+    context: NixxieContext<TypeInfo>
+  ): Promise<void>
+  delete(key: string, context: NixxieContext<TypeInfo>): Promise<void>
+  url(key: string, context: NixxieContext<TypeInfo>): MaybePromise<string>
+}

package/static/admin-error.html

@@ -0,0 +1,53 @@
+<!doctype html>
+<html>
+  <head>
+    <meta http-equiv="Content-type" content="text/html; charset=utf-8" />
+    <title>NixxieCMS</title>
+    <style type="text/css">
+      html,
+      body {
+        height: 100vh;
+      }
+      body {
+        align-items: center;
+        background-color: #fafbfc;
+        color: #172b4d;
+        display: flex;
+        flex-direction: column;
+        font-family:
+          -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif,
+          'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol';
+        font-size: 15px;
+        justify-content: center;
+        letter-spacing: -0.005em;
+        margin: 0;
+        padding: 0;
+        text-decoration-skip: ink;
+        text-rendering: optimizeLegibility;
+        -ms-overflow-style: -ms-autohiding-scrollbar;
+        -moz-osx-font-smoothing: grayscale;
+        -webkit-font-smoothing: antialiased;
+      }
+      h1 {
+        font-weight: 300;
+        margin-bottom: 0.66em;
+        margin-top: 0;
+      }
+      p {
+        color: #6c798f;
+      }
+      .container {
+        margin-top: -4vh;
+        padding-left: 1em;
+        padding-right: 1em;
+        text-align: center;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="container">
+      <h1 id="status">Error</h1>
+      <p id="message">Something went wrong loading the Admin UI</p>
+    </div>
+  </body>
+</html>

package/static/dev-loading.html

@@ -0,0 +1,146 @@
+<!doctype html>
+<html>
+  <head>
+    <meta http-equiv="Content-type" content="text/html; charset=utf-8" />
+    <title>NixxieCMS</title>
+    <style type="text/css">
+      html,
+      body {
+        height: 100vh;
+      }
+      body {
+        align-items: center;
+        background-color: #fafbfc;
+        color: #172b4d;
+        display: flex;
+        flex-direction: column;
+        font-family:
+          -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif,
+          'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol';
+        font-size: 15px;
+        justify-content: center;
+        letter-spacing: -0.005em;
+        margin: 0;
+        padding: 0;
+        text-decoration-skip: ink;
+        text-rendering: optimizeLegibility;
+        -ms-overflow-style: -ms-autohiding-scrollbar;
+        -moz-osx-font-smoothing: grayscale;
+        -webkit-font-smoothing: antialiased;
+      }
+      h1 {
+        font-weight: 300;
+        margin-bottom: 0.66em;
+        margin-top: 0;
+      }
+      p {
+        color: #6c798f;
+      }
+      .container {
+        margin-top: -4vh;
+        padding-left: 1em;
+        padding-right: 1em;
+        text-align: center;
+      }
+      /* Loading spinner from loading.io/css */
+      .loading-spinner {
+        display: inline-block;
+        height: 64px;
+        position: relative;
+        width: 64px;
+      }
+      .loading-spinner > div {
+        animation-timing-function: cubic-bezier(0, 1, 1, 0);
+        background: #172b4d;
+        border-radius: 50%;
+        height: 11px;
+        position: absolute;
+        top: 27px;
+        width: 11px;
+      }
+      .loading-spinner div:nth-child(1) {
+        animation: loading-spinner1 0.6s infinite;
+        left: 6px;
+      }
+      .loading-spinner div:nth-child(2) {
+        animation: loading-spinner2 0.6s infinite;
+        left: 6px;
+      }
+      .loading-spinner div:nth-child(3) {
+        animation: loading-spinner2 0.6s infinite;
+        left: 26px;
+      }
+      .loading-spinner div:nth-child(4) {
+        animation: loading-spinner3 0.6s infinite;
+        left: 45px;
+      }
+      @keyframes loading-spinner1 {
+        0% {
+          opacity: 0;
+          transform: scale(0);
+        }
+        100% {
+          opacity: 1;
+          transform: scale(1);
+        }
+      }
+      @keyframes loading-spinner3 {
+        0% {
+          opacity: 1;
+          transform: scale(1);
+        }
+        100% {
+          opacity: 0;
+          transform: scale(0);
+        }
+      }
+      @keyframes loading-spinner2 {
+        0% {
+          transform: translate(0, 0);
+        }
+        100% {
+          transform: translate(19px, 0);
+        }
+      }
+    </style>
+  </head>
+  <body>
+    <div class="container">
+      <div class="loading-spinner">
+        <div></div>
+        <div></div>
+        <div></div>
+        <div></div>
+      </div>
+
+      <h1 id="status">Nixxie is loading...</h1>
+      <p id="message">This page will reload when the server is ready</p>
+    </div>
+    <script>
+      const statusEl = document.querySelector('#status')
+      const messageEl = document.querySelector('#message')
+      const loadingEl = document.querySelector('.loading-spinner')
+
+      function onError(err) {
+        statusEl.innerHTML = 'Error'
+        messageEl.innerHTML = 'Please check your console.'
+        loadingEl.remove()
+        throw err
+      }
+
+      function onReady() {
+        statusEl.innerHTML = 'Nixxie is ready!'
+        messageEl.innerHTML = 'Reloading the page...'
+        location.reload(true)
+      }
+
+      async function checkStatus() {
+        const res = await fetch('/__nixxie/dev/status')
+        if (res.status === 200) return onReady()
+        setTimeout(checkStatus, 400)
+      }
+
+      checkStatus()
+    </script>
+  </body>
+</html>

package/static/favicon.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32" fill="none">
+  <rect width="32" height="32" rx="6" fill="#000000"/>
+  <path d="M7 25V7L25 25V7" stroke="white" stroke-width="3.5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

package/system/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "dist/nixxie-core-system.cjs.js",
+  "module": "dist/nixxie-core-system.esm.js"
+}

package/testing/dist/nixxie-cms-core-testing.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "../../dist/declarations/src/testing.js";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibml4eGllLWNtcy1jb3JlLXRlc3RpbmcuY2pzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9kaXN0L2RlY2xhcmF0aW9ucy9zcmMvdGVzdGluZy5kLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBIn0=