@nixxie-cms/core 1.0.0

package/scripts/cli/package.json

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

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

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

package/scripts/dist/nixxie-cms-core-scripts.cjs.js

@@ -0,0 +1,73 @@
+'use strict';
+
+var scripts_cli_dist_nixxieCmsCoreScriptsCli = require('../cli/dist/nixxie-cms-core-scripts-cli.cjs.js');
+var express = require('../../dist/express-e9ed9a7d.cjs.js');
+require('meow');
+require('esbuild');
+require('@nodelib/fs.walk');
+require('fs-extra');
+require('node:fs/promises');
+require('node:path');
+require('node:util');
+require('resolve');
+require('../../dist/system-48c5f6df.cjs.js');
+require('node:crypto');
+require('../../dist/admin-meta-18d0c276.cjs.js');
+require('graphql');
+require('@graphql-ts/schema');
+require('../../dist/resolve-hooks-66fe8a8e.cjs.js');
+require('pluralize');
+require('../../dist/next-fields-49c025ef.cjs.js');
+require('decimal.js');
+require('@graphql-ts/extend');
+require('graphql-upload/GraphQLUpload.js');
+require('../../dist/utils-e74e3527.cjs.js');
+require('../../dist/utils-1b632a8f.cjs.js');
+require('../../access/dist/nixxie-cms-core-access.cjs.js');
+require('graphql/execution/values');
+require('../../dist/utils-b031e11c.cjs.js');
+require('@apollo/cache-control-types');
+require('dataloader');
+require('@babel/runtime/helpers/classPrivateFieldInitSpec');
+require('@babel/runtime/helpers/classPrivateFieldGet2');
+require('@babel/runtime/helpers/classPrivateFieldSet2');
+require('@opentelemetry/api');
+require('node:module');
+require('node:http');
+require('@prisma/internals');
+require('chalk');
+require('express');
+require('next');
+require('path');
+require('../../dist/migrations-ab2e0fd4.cjs.js');
+require('@prisma/migrate');
+require('prompts');
+require('node:os');
+require('node:https');
+require('ci-info');
+require('conf');
+require('node:child_process');
+require('@prisma/client-generator-registry');
+require('http');
+require('cors');
+require('body-parser');
+require('@apollo/server/express4');
+require('@apollo/server');
+require('@apollo/server/plugin/disabled');
+require('@apollo/server/plugin/landingPage/default');
+require('graphql-upload/graphqlUploadExpress.js');
+
+async function main() {
+  const argv = process.argv.slice(2);
+  await scripts_cli_dist_nixxieCmsCoreScriptsCli.cli(process.cwd(), argv);
+
+  // WARNING: see https://github.com/nixxiecms/nixxie/pull/8788
+  if (argv[0] === 'build') {
+    process.exit(0);
+  }
+}
+main().catch(err => {
+  if (err instanceof express.ExitError) return process.exit(err.code);
+  console.error(err);
+  process.exit(1);
+});

package/scripts/dist/nixxie-cms-core-scripts.esm.js

@@ -0,0 +1,71 @@
+import { cli } from '../cli/dist/nixxie-cms-core-scripts-cli.esm.js';
+import { E as ExitError } from '../../dist/express-6743b918.esm.js';
+import 'meow';
+import 'esbuild';
+import '@nodelib/fs.walk';
+import 'fs-extra';
+import 'node:fs/promises';
+import 'node:path';
+import 'node:util';
+import 'resolve';
+import '../../dist/system-dfec2f0a.esm.js';
+import 'node:crypto';
+import '../../dist/admin-meta-14c60fec.esm.js';
+import 'graphql';
+import '@graphql-ts/schema';
+import '../../dist/resolve-hooks-17aafd37.esm.js';
+import 'pluralize';
+import '../../dist/next-fields-9bf04ed8.esm.js';
+import 'decimal.js';
+import '@graphql-ts/extend';
+import 'graphql-upload/GraphQLUpload.js';
+import '../../dist/utils-ef2cd0f4.esm.js';
+import '../../dist/utils-0cc426c8.esm.js';
+import '../../access/dist/nixxie-cms-core-access.esm.js';
+import 'graphql/execution/values';
+import '../../dist/utils-f9556354.esm.js';
+import '@apollo/cache-control-types';
+import 'dataloader';
+import '@babel/runtime/helpers/classPrivateFieldInitSpec';
+import '@babel/runtime/helpers/classPrivateFieldGet2';
+import '@babel/runtime/helpers/classPrivateFieldSet2';
+import '@opentelemetry/api';
+import 'node:module';
+import 'node:http';
+import '@prisma/internals';
+import 'chalk';
+import 'express';
+import 'next';
+import 'path';
+import '../../dist/migrations-996e66a0.esm.js';
+import '@prisma/migrate';
+import 'prompts';
+import 'node:os';
+import 'node:https';
+import 'ci-info';
+import 'conf';
+import 'node:child_process';
+import '@prisma/client-generator-registry';
+import 'http';
+import 'cors';
+import 'body-parser';
+import '@apollo/server/express4';
+import '@apollo/server';
+import '@apollo/server/plugin/disabled';
+import '@apollo/server/plugin/landingPage/default';
+import 'graphql-upload/graphqlUploadExpress.js';
+
+async function main() {
+  const argv = process.argv.slice(2);
+  await cli(process.cwd(), argv);
+
+  // WARNING: see https://github.com/nixxiecms/nixxie/pull/8788
+  if (argv[0] === 'build') {
+    process.exit(0);
+  }
+}
+main().catch(err => {
+  if (err instanceof ExitError) return process.exit(err.code);
+  console.error(err);
+  process.exit(1);
+});

package/scripts/package.json

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

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

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

package/session/dist/nixxie-cms-core-session.cjs.js

@@ -0,0 +1,157 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var node_crypto = require('node:crypto');
+var cookie = require('cookie');
+var Iron = require('@hapi/iron');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var cookie__namespace = /*#__PURE__*/_interopNamespace(cookie);
+var Iron__default = /*#__PURE__*/_interopDefault(Iron);
+
+// TODO: should we also accept httpOnly?
+
+function getToken(req, cookieName) {
+  var _req$headers$authoriz;
+  const authorization = (_req$headers$authoriz = req.headers.authorization) !== null && _req$headers$authoriz !== void 0 ? _req$headers$authoriz : '';
+  if (authorization.startsWith('Bearer')) {
+    return authorization.slice('Bearer '.length);
+  }
+  const cookies = cookie__namespace.parse(req.headers.cookie || '');
+  return cookies[cookieName];
+}
+function statelessSessions({
+  secret = node_crypto.randomBytes(32).toString('base64url'),
+  maxAge = 60 * 60 * 8,
+  // 8 hours,
+  cookieName = 'nixxiecms-session',
+  path = '/',
+  secure = process.env.NODE_ENV === 'production',
+  ironOptions = Iron__default["default"].defaults,
+  domain,
+  sameSite = 'lax'
+} = {}) {
+  // atleast 192-bit in base64
+  if (secret.length < 32) {
+    throw new Error('The session secret must be at least 32 characters long');
+  }
+  return {
+    async get({
+      context
+    }) {
+      if (!(context !== null && context !== void 0 && context.req)) return;
+      const token = getToken(context.req, cookieName);
+      if (!token) return;
+      try {
+        return await Iron__default["default"].unseal(token, secret, ironOptions);
+      } catch (err) {
+        // do nothing
+      }
+    },
+    async end({
+      context
+    }) {
+      if (!(context !== null && context !== void 0 && context.res)) return;
+      context.res.setHeader('Set-Cookie', cookie__namespace.serialize(cookieName, '', {
+        maxAge: 0,
+        expires: new Date(),
+        httpOnly: true,
+        secure,
+        path,
+        sameSite,
+        domain
+      }));
+    },
+    async start({
+      context,
+      data
+    }) {
+      if (!(context !== null && context !== void 0 && context.res)) return;
+      const sealedData = await Iron__default["default"].seal(data, secret, {
+        ...ironOptions,
+        ttl: maxAge * 1000
+      });
+      context.res.setHeader('Set-Cookie', cookie__namespace.serialize(cookieName, sealedData, {
+        maxAge,
+        expires: new Date(Date.now() + maxAge * 1000),
+        httpOnly: true,
+        secure,
+        path,
+        sameSite,
+        domain
+      }));
+      return sealedData;
+    }
+  };
+}
+function storedSessions({
+  store: storeFn,
+  maxAge = 60 * 60 * 8,
+  // 8 hours
+  ...statelessSessionsOptions
+}) {
+  const stateless = statelessSessions({
+    ...statelessSessionsOptions,
+    maxAge
+  });
+  const store = storeFn({
+    maxAge
+  });
+  return {
+    async get({
+      context
+    }) {
+      const sessionId = await stateless.get({
+        context
+      });
+      if (!sessionId) return;
+      return store.get(sessionId);
+    },
+    async start({
+      context,
+      data
+    }) {
+      const sessionId = node_crypto.randomBytes(24).toString('base64url'); // 192-bit
+      await store.set(sessionId, data);
+      return stateless.start({
+        context,
+        data: sessionId
+      }) || '';
+    },
+    async end({
+      context
+    }) {
+      const sessionId = await stateless.get({
+        context
+      });
+      if (!sessionId) return;
+      await store.delete(sessionId);
+      await stateless.end({
+        context
+      });
+    }
+  };
+}
+
+exports.statelessSessions = statelessSessions;
+exports.storedSessions = storedSessions;

package/session/dist/nixxie-cms-core-session.esm.js

@@ -0,0 +1,129 @@
+import { randomBytes } from 'node:crypto';
+import * as cookie from 'cookie';
+import Iron from '@hapi/iron';
+
+// TODO: should we also accept httpOnly?
+
+function getToken(req, cookieName) {
+  var _req$headers$authoriz;
+  const authorization = (_req$headers$authoriz = req.headers.authorization) !== null && _req$headers$authoriz !== void 0 ? _req$headers$authoriz : '';
+  if (authorization.startsWith('Bearer')) {
+    return authorization.slice('Bearer '.length);
+  }
+  const cookies = cookie.parse(req.headers.cookie || '');
+  return cookies[cookieName];
+}
+function statelessSessions({
+  secret = randomBytes(32).toString('base64url'),
+  maxAge = 60 * 60 * 8,
+  // 8 hours,
+  cookieName = 'nixxiecms-session',
+  path = '/',
+  secure = process.env.NODE_ENV === 'production',
+  ironOptions = Iron.defaults,
+  domain,
+  sameSite = 'lax'
+} = {}) {
+  // atleast 192-bit in base64
+  if (secret.length < 32) {
+    throw new Error('The session secret must be at least 32 characters long');
+  }
+  return {
+    async get({
+      context
+    }) {
+      if (!(context !== null && context !== void 0 && context.req)) return;
+      const token = getToken(context.req, cookieName);
+      if (!token) return;
+      try {
+        return await Iron.unseal(token, secret, ironOptions);
+      } catch (err) {
+        // do nothing
+      }
+    },
+    async end({
+      context
+    }) {
+      if (!(context !== null && context !== void 0 && context.res)) return;
+      context.res.setHeader('Set-Cookie', cookie.serialize(cookieName, '', {
+        maxAge: 0,
+        expires: new Date(),
+        httpOnly: true,
+        secure,
+        path,
+        sameSite,
+        domain
+      }));
+    },
+    async start({
+      context,
+      data
+    }) {
+      if (!(context !== null && context !== void 0 && context.res)) return;
+      const sealedData = await Iron.seal(data, secret, {
+        ...ironOptions,
+        ttl: maxAge * 1000
+      });
+      context.res.setHeader('Set-Cookie', cookie.serialize(cookieName, sealedData, {
+        maxAge,
+        expires: new Date(Date.now() + maxAge * 1000),
+        httpOnly: true,
+        secure,
+        path,
+        sameSite,
+        domain
+      }));
+      return sealedData;
+    }
+  };
+}
+function storedSessions({
+  store: storeFn,
+  maxAge = 60 * 60 * 8,
+  // 8 hours
+  ...statelessSessionsOptions
+}) {
+  const stateless = statelessSessions({
+    ...statelessSessionsOptions,
+    maxAge
+  });
+  const store = storeFn({
+    maxAge
+  });
+  return {
+    async get({
+      context
+    }) {
+      const sessionId = await stateless.get({
+        context
+      });
+      if (!sessionId) return;
+      return store.get(sessionId);
+    },
+    async start({
+      context,
+      data
+    }) {
+      const sessionId = randomBytes(24).toString('base64url'); // 192-bit
+      await store.set(sessionId, data);
+      return stateless.start({
+        context,
+        data: sessionId
+      }) || '';
+    },
+    async end({
+      context
+    }) {
+      const sessionId = await stateless.get({
+        context
+      });
+      if (!sessionId) return;
+      await store.delete(sessionId);
+      await stateless.end({
+        context
+      });
+    }
+  };
+}
+
+export { statelessSessions, storedSessions };

package/session/package.json

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

package/src/___internal-do-not-use-will-break-in-patch/admin-ui/id-field-view.tsx

@@ -0,0 +1,167 @@
+import { useCallback, useState } from 'react'
+import { useListFormatter } from '@react-aria/i18n'
+import copyToClipboard from 'clipboard-copy'
+
+import { ActionButton } from '@keystar/ui/button'
+import { Icon } from '@keystar/ui/icon'
+import { clipboardIcon } from '@keystar/ui/icon/icons/clipboardIcon'
+import { Grid } from '@keystar/ui/layout'
+import { TooltipTrigger, Tooltip } from '@keystar/ui/tooltip'
+import { TextField } from '@keystar/ui/text-field'
+
+import type { FieldController, FieldControllerConfig, FieldProps, IdFieldConfig } from '../../types'
+import type { InferValueFromInputType } from '@graphql-ts/schema'
+import type { filters } from '../../fields/filters'
+import { entriesTyped } from '../../lib/core/utils'
+
+const COPY_TOOLTIP_CONTENT = {
+  neutral: 'Copy ID',
+  positive: 'Copied to clipboard',
+  critical: 'Unable to copy',
+}
+type TooltipState = { isOpen?: boolean; tone: keyof typeof COPY_TOOLTIP_CONTENT }
+
+export function Field({ value }: FieldProps<typeof controller>) {
+  const [tooltipState, setTooltipState] = useState<TooltipState>({ tone: 'neutral' })
+
+  const onCopy = useCallback(async () => {
+    try {
+      if (value) await copyToClipboard(value)
+      setTooltipState({ isOpen: true, tone: 'positive' })
+    } catch (err: any) {
+      setTooltipState({ isOpen: true, tone: 'critical' })
+    }
+
+    // close, then reset the tooltip state after a delay
+    setTimeout(() => {
+      setTooltipState(state => ({ ...state, isOpen: false }))
+    }, 2000)
+    setTimeout(() => {
+      setTooltipState({ isOpen: undefined, tone: 'neutral' })
+    }, 2300)
+  }, [value])
+
+  return (
+    <Grid gap="regular" columns="1fr auto" alignItems="end">
+      <TextField
+        label="Item ID"
+        value={value ?? ''}
+        isReadOnly
+        onFocus={({ target }) => {
+          if (target instanceof HTMLInputElement) target.select()
+        }}
+      />
+      <TooltipTrigger isOpen={tooltipState.isOpen} placement="top end">
+        <ActionButton aria-label="copy id" onPress={onCopy}>
+          <Icon src={clipboardIcon} />
+        </ActionButton>
+        <Tooltip tone={tooltipState.tone}>{COPY_TOOLTIP_CONTENT[tooltipState.tone]}</Tooltip>
+      </TooltipTrigger>
+    </Grid>
+  )
+}
+
+export function controller(
+  config: FieldControllerConfig<IdFieldConfig>
+): FieldController<
+  string | null,
+  string | string[],
+  InferValueFromInputType<(typeof filters)['mysql']['String']['required']>
+> {
+  return {
+    fieldKey: config.fieldKey,
+    label: config.label,
+    description: config.description,
+    defaultValue: null,
+    deserialize: data => data[config.fieldKey],
+    serialize: value => ({ [config.fieldKey]: value }),
+    graphqlSelection: config.fieldKey,
+    filter: {
+      Filter(props) {
+        const { autoFocus, context, onChange, type, typeLabel, value, ...otherProps } = props
+        const labelProps =
+          context === 'add' ? { label: config.label, description: typeLabel } : { label: typeLabel }
+        const [inputValue, setInputValue] = useState(() =>
+          Array.isArray(value) ? value.join(', ') : value
+        )
+        const [lastSeenValue, setLastSeenValue] = useState(value)
+        if (value !== lastSeenValue && Array.isArray(value)) {
+          setInputValue(value.join(', '))
+          setLastSeenValue(value)
+        }
+
+        return (
+          <TextField
+            {...otherProps}
+            {...labelProps}
+            autoFocus={autoFocus}
+            onChange={newVal => {
+              if (Array.isArray(value)) {
+                setInputValue(newVal)
+              } else {
+                onChange(newVal)
+              }
+            }}
+            onBlur={() => {
+              if (Array.isArray(value)) {
+                onChange(inputValue.split(',').map(val => val.trim()))
+              }
+            }}
+            value={Array.isArray(value) ? inputValue : value}
+          />
+        )
+      },
+
+      Label({ label, value, type }) {
+        const listFormatter = useListFormatter({
+          style: 'short',
+          type: 'disjunction',
+        })
+
+        if (['in', 'not_in'].includes(type)) {
+          return `${label.toLowerCase()} (${listFormatter.format(value)})`
+        }
+        return `${label.toLowerCase()} ${value}`
+      },
+      graphql: ({ type, value }) => {
+        const valueWithoutWhitespace = Array.isArray(value)
+          ? value.map(val => val.replace(/\s/g, ''))
+          : value.replace(/\s/g, '')
+        if (type === 'not')
+          return { [config.fieldKey]: { not: { equals: valueWithoutWhitespace } } }
+        const key = type === 'is' ? 'equals' : type === 'not_in' ? 'notIn' : type
+
+        return {
+          [config.fieldKey]: {
+            [key]: valueWithoutWhitespace,
+          },
+        }
+      },
+      parseGraphQL: value => {
+        return entriesTyped(value).flatMap(([type, value]) => {
+          if (!value) return []
+          if (type === 'equals') return { type: 'is', value }
+          if (type === 'notIn') return { type: 'not_in', value }
+          if (type === 'in') return { type: 'in', value }
+          if (type === 'not' && value?.equals) {
+            return { type: 'not', value: value?.equals }
+          }
+          if (type === 'gt' || type === 'gte' || type === 'lt' || type === 'lte') {
+            return { type, value }
+          }
+          return []
+        })
+      },
+      types: {
+        is: { label: 'Is exactly', initialValue: '' },
+        not: { label: 'Is not exactly', initialValue: '' },
+        gt: { label: 'Is greater than', initialValue: '' },
+        lt: { label: 'Is less than', initialValue: '' },
+        gte: { label: 'Is greater than or equal to', initialValue: '' },
+        lte: { label: 'Is less than or equal to', initialValue: '' },
+        in: { label: 'Is one of', initialValue: [] },
+        not_in: { label: 'Is not one of', initialValue: [] },
+      },
+    },
+  }
+}

package/src/___internal-do-not-use-will-break-in-patch/admin-ui/pages/App/index.tsx

@@ -0,0 +1,22 @@
+import type { AppProps } from 'next/app'
+import type { AdminConfig, FieldViews } from '../../../../types'
+import { ErrorBoundary } from '../../../../admin-ui/components'
+import { NixxieProvider } from '../../../../admin-ui/context'
+
+type AppConfig = {
+  adminConfig: AdminConfig
+  fieldViews: FieldViews
+  apiPath: string
+}
+
+export const getApp =
+  (props: AppConfig) =>
+  ({ Component, pageProps }: AppProps) => {
+    return (
+      <NixxieProvider {...props}>
+        <ErrorBoundary>
+          <Component {...pageProps} />
+        </ErrorBoundary>
+      </NixxieProvider>
+    )
+  }