@unchainedshop/api 3.0.0-alpha2 → 3.0.0-alpha4

package/src/api-index.ts

@@ -1,60 +1,46 @@
-import fs from 'fs';
-import path from 'path';
-import { AdminUiConfig } from '@unchainedshop/types/api.js';
-import createGraphQLServer from './createGraphQLServer.js';
+import createGraphQLServer, { GraphQLServerOptions } from './createGraphQLServer.js';
 import {
   createContextResolver,
   setCurrentContextResolver,
   getCurrentContextResolver,
 } from './context.js';
-import { YogaServerOptions } from 'graphql-yoga';
-import { UnchainedCore } from '@unchainedshop/types/core.js';
+import { UnchainedCore } from '@unchainedshop/core';
+import { AdminUiConfig } from './types.js';
 
 export * from './context.js';
+export * from './types.js';
 export * as acl from './acl.js';
 export * as errors from './errors.js';
-export * as express from './express/index.js';
 export * as roles from './roles/index.js';
 export { createContextResolver, getCurrentContextResolver, setCurrentContextResolver };
 
-export const loadJSON = (filename) => {
-  try {
-    const base = typeof __filename !== 'undefined' && __filename;
-    if (!base)
-      return {
-        version: process.env.npm_package_version,
-      };
-    const absolutePath = path.resolve(path.dirname(base), filename);
-    const data = JSON.parse(fs.readFileSync(absolutePath, 'utf-8'));
-    return data;
-  } catch (e) {
-    return null;
-  }
-};
-const packageJson = loadJSON('../package.json');
-
-const { UNCHAINED_API_VERSION = packageJson?.version || '2.x' } = process.env;
-
-export type GraphQLServerOptions = YogaServerOptions<any, any>;
+import { buildDefaultTypeDefs } from './schema/index.js';
+import resolvers from './resolvers/index.js';
+import { actions } from './roles/index.js';
 
-export type UnchainedServerOptions = GraphQLServerOptions & {
-  unchainedAPI: UnchainedCore;
+export type UnchainedServerOptions = {
   roles?: any;
+  adminUiConfig?: AdminUiConfig;
+  unchainedAPI: UnchainedCore;
   context?: any;
   events: Array<string>;
   workTypes: Array<string>;
-  adminUiConfig?: AdminUiConfig;
-};
+} & GraphQLServerOptions;
 
 export const startAPIServer = async (options: UnchainedServerOptions) => {
-  const { unchainedAPI, roles, context: customContext, adminUiConfig, ...serverOptions } = options || {};
-
-  const contextResolver = createContextResolver(
+  const {
     unchainedAPI,
+    context: customContext,
     roles,
-    UNCHAINED_API_VERSION,
-    adminUiConfig,
-  );
+    adminUiConfig = {},
+    events,
+    workTypes,
+    typeDefs: additionalTypeDefs = [],
+    resolvers: additionalResolvers = [],
+    ...serverOptions
+  } = options || {};
+
+  const contextResolver = createContextResolver(unchainedAPI, { roles, adminUiConfig });
 
   setCurrentContextResolver(
     customContext
@@ -64,5 +50,16 @@ export const startAPIServer = async (options: UnchainedServerOptions) => {
       : contextResolver,
   );
 
-  return createGraphQLServer(serverOptions);
+  return createGraphQLServer({
+    typeDefs: [
+      ...buildDefaultTypeDefs({
+        actions: Object.keys(actions),
+        events,
+        workTypes,
+      }),
+      ...additionalTypeDefs,
+    ],
+    resolvers: [resolvers, ...additionalResolvers],
+    ...serverOptions,
+  });
 };

package/src/context.ts

@@ -1,7 +1,10 @@
-import { AdminUiConfig, Context, UnchainedHTTPServerContext } from '@unchainedshop/types/api.js';
-import { UnchainedCore } from '@unchainedshop/types/core.js';
+import fs from 'fs';
+import path from 'path';
+import { UnchainedCore } from '@unchainedshop/core';
 import instantiateLoaders from './loaders/index.js';
 import { getLocaleContext } from './locale-context.js';
+import { UnchainedServerOptions } from './api-index.js';
+import { Context, UnchainedHTTPServerContext } from './types.js';
 
 let context;
 
@@ -13,7 +16,6 @@ export const setCurrentContextResolver = (newContext: UnchainedContextResolver)
 
 export type UnchainedContextResolver = (
   params: UnchainedHTTPServerContext & {
-    cookies?: Record<string, string>;
     remoteAddress?: string;
     remotePort?: number;
     user?: any;
@@ -23,29 +25,43 @@ export type UnchainedContextResolver = (
   },
 ) => Promise<Context>;
 
+export const loadJSON = (filename) => {
+  try {
+    const base = typeof __filename !== 'undefined' && __filename;
+    if (!base)
+      return {
+        version: process.env.npm_package_version,
+      };
+    const absolutePath = path.resolve(path.dirname(base), filename);
+    const data = JSON.parse(fs.readFileSync(absolutePath, 'utf-8'));
+    return data;
+  } catch {
+    return null;
+  }
+};
+
+const packageJson = loadJSON('../package.json');
+
+const { UNCHAINED_API_VERSION = packageJson?.version || '2.x' } = process.env;
+
 export const createContextResolver =
   (
     unchainedAPI: UnchainedCore,
-    roles: any,
-    version: string,
-    adminUiConfig?: AdminUiConfig,
+    unchainedConfig: Pick<UnchainedServerOptions, 'roles' | 'adminUiConfig'>,
   ): UnchainedContextResolver =>
-  async ({ getHeader, setHeader, cookies, remoteAddress, remotePort, user, userId, login, logout }) => {
-    const abstractHttpServerContext = { remoteAddress, remotePort, getHeader, setHeader, cookies };
+  async ({ getHeader, setHeader, remoteAddress, remotePort, user, userId, login, logout }) => {
+    const abstractHttpServerContext = { remoteAddress, remotePort, getHeader, setHeader };
     const loaders = await instantiateLoaders(unchainedAPI);
     const localeContext = await getLocaleContext(abstractHttpServerContext, unchainedAPI);
+    const userContext = { user, userId, login, logout };
 
     return {
       ...unchainedAPI,
+      ...unchainedConfig,
       ...localeContext,
-      user,
-      userId,
-      login,
-      logout,
+      ...userContext,
       loaders,
-      roles,
-      version,
-      adminUiConfig,
+      version: UNCHAINED_API_VERSION,
       setHeader,
       getHeader,
     };

package/src/createGraphQLServer.ts

@@ -1,33 +1,21 @@
 import { createLogger } from '@unchainedshop/logger';
-import { buildDefaultTypeDefs } from './schema/index.js';
-import resolvers from './resolvers/index.js';
-import { actions } from './roles/index.js';
-import { createYoga, createSchema } from 'graphql-yoga';
+import { createYoga, createSchema, YogaServerOptions } from 'graphql-yoga';
 
 const logger = createLogger('unchained:api');
 
-export default async (options) => {
-  const {
-    typeDefs: additionalTypeDefs = [],
-    resolvers: additionalResolvers = [],
-    events = [],
-    workTypes = [],
-    schema: customSchema,
-    ...graphQLServerOptions
-  } = options || {};
+export type GraphQLServerOptions = YogaServerOptions<any, any> & {
+  typeDefs?: Array<string>;
+  resolvers?: Array<Record<string, any>>;
+};
+
+export default async (options: GraphQLServerOptions) => {
+  const { typeDefs, resolvers, schema: customSchema, ...graphQLServerOptions } = options || {};
 
   const schema =
     customSchema ||
     createSchema({
-      typeDefs: [
-        ...buildDefaultTypeDefs({
-          actions: Object.keys(actions),
-          events,
-          workTypes,
-        }),
-        ...additionalTypeDefs,
-      ],
-      resolvers: [resolvers, ...additionalResolvers],
+      typeDefs,
+      resolvers,
     });
 
   const server = createYoga({

package/src/express/createBulkImportMiddleware.ts

@@ -2,7 +2,7 @@ import { createLogger } from '@unchainedshop/logger';
 import { checkAction } from '../acl.js';
 import { actions } from '../roles/index.js';
 import { IncomingMessage } from 'http';
-import { Context } from '@unchainedshop/types/api.js';
+import { Context } from '../types.js';
 
 const logger = createLogger('unchained:bulk-import');
 

package/src/express/createERCMetadataMiddleware.ts

@@ -2,10 +2,7 @@ import { IncomingMessage } from 'http';
 import path from 'path';
 import { createLogger } from '@unchainedshop/logger';
 import { systemLocale } from '@unchainedshop/utils';
-import localePkg from 'locale';
-import { Context } from '@unchainedshop/types/api.js';
-
-const { Locale } = localePkg;
+import { Context } from '../types.js';
 
 const logger = createLogger('unchained:erc-metadata');
 
@@ -56,7 +53,7 @@ export default async function ercMetadataMiddleware(
       {
         token,
         product,
-        locale: new Locale(locale),
+        locale: new Intl.Locale(locale),
         referenceDate: new Date(),
       },
       context,

package/src/express/index.ts

@@ -2,26 +2,24 @@ import type e from 'express';
 import { getCurrentContextResolver } from '../context.js';
 import createBulkImportMiddleware from './createBulkImportMiddleware.js';
 import createERCMetadataMiddleware from './createERCMetadataMiddleware.js';
-import cookieParser from 'cookie-parser';
 import session from 'express-session';
 import MongoStore from 'connect-mongo';
-import { YogaServer } from 'graphql-yoga';
+import { YogaServerInstance } from 'graphql-yoga';
 import setupPassport from './passport/setup.js';
 import { mongodb } from '@unchainedshop/mongodb';
-import { UnchainedCore } from '@unchainedshop/types/core.js';
+import { UnchainedCore } from '@unchainedshop/core';
 import { emit } from '@unchainedshop/events';
 import { API_EVENTS } from '../events.js';
+import { User } from '@unchainedshop/core-users';
+import { IncomingMessage } from 'http';
 
-const resolveUserRemoteAddress = (req) => {
+const resolveUserRemoteAddress = (req: IncomingMessage) => {
   const remoteAddress =
-    req.headers['x-real-ip'] ||
-    req.headers['x-forwarded-for'] ||
-    req.connection?.remoteAddress ||
-    req.socket?.remoteAddress ||
-    req.connection?.socket?.remoteAddress;
+    (req.headers['x-real-ip'] as string) ||
+    (req.headers['x-forwarded-for'] as string) ||
+    req.socket?.remoteAddress;
 
-  const remotePort =
-    req.connection?.remotePort || req.socket?.remotePort || req.connection?.socket?.remotePort;
+  const remotePort = req.socket?.remotePort;
 
   return { remoteAddress, remotePort };
 };
@@ -37,19 +35,18 @@ const {
 } = process.env;
 
 const addContext = async function middlewareWithContext(
-  req: e.Request & { cookies: any },
+  req: e.Request,
   res: e.Response,
   next: e.NextFunction,
 ) {
   try {
     const setHeader = (key, value) => res.setHeader(key, value);
     const getHeader = (key) => req.headers[key];
-    const cookies = req.cookies;
     const { remoteAddress, remotePort } = resolveUserRemoteAddress(req);
 
     const context = getCurrentContextResolver();
 
-    const login = async (user) => {
+    const login = async (user: User) => {
       await new Promise((resolve, reject) => {
         (req as any).login(user, (error, result) => {
           if (error) {
@@ -100,7 +97,6 @@ const addContext = async function middlewareWithContext(
     (req as any).unchainedContext = await context({
       setHeader,
       getHeader,
-      cookies,
       remoteAddress,
       remotePort,
       login,
@@ -117,14 +113,13 @@ const addContext = async function middlewareWithContext(
 export const connect = (
   expressApp: e.Express,
   {
-    yogaServer,
+    graphqlHandler,
     db,
     unchainedAPI,
-  }: { yogaServer: YogaServer<any, any>; db: mongodb.Db; unchainedAPI: UnchainedCore },
+  }: { graphqlHandler: YogaServerInstance<any, any>; db: mongodb.Db; unchainedAPI: UnchainedCore },
 ) => {
-  expressApp.use(cookieParser(), addContext);
   const passport = setupPassport(unchainedAPI);
-  expressApp.use(passport.initialize());
+
   expressApp.use(
     session({
       secret: process.env.UNCHAINED_TOKEN_SECRET,
@@ -138,17 +133,19 @@ export const connect = (
       resave: false,
       cookie: {
         domain: UNCHAINED_COOKIE_DOMAIN,
-        httpOnly: true,
+        httpOnly: Boolean(NODE_ENV === 'production'),
         path: UNCHAINED_COOKIE_PATH,
-        sameSite: NODE_ENV === 'production' ? 'lax' : 'none',
+        sameSite: 'lax',
         secure: NODE_ENV === 'production',
         maxAge: 1000 * 60 * 60 * 24 * 7,
       },
     }),
+    passport.initialize(),
+    passport.session(),
+    passport.authenticate('access-token', { session: false }),
+    addContext,
   );
-  expressApp.use(passport.session());
-  expressApp.use(passport.authenticate('access-token', { session: false }));
-  expressApp.use(GRAPHQL_API_PATH, yogaServer.handle);
+  expressApp.use(GRAPHQL_API_PATH, graphqlHandler.handle);
   expressApp.use(ERC_METADATA_API_PATH, createERCMetadataMiddleware);
   expressApp.use(BULK_IMPORT_API_PATH, createBulkImportMiddleware);
 };

package/src/express/passport/setup.ts

@@ -1,4 +1,4 @@
-import { UnchainedCore } from '@unchainedshop/types/core.js';
+import { UnchainedCore } from '@unchainedshop/core';
 import { Passport } from 'passport';
 import AccessTokenStrategy from './access-token-strategy.js';
 

package/src/fastify/index.ts

@@ -0,0 +1,128 @@
+import { getCurrentContextResolver } from '../context.js';
+// import createBulkImportMiddleware from './createBulkImportMiddleware.js';
+// import createERCMetadataMiddleware from './createERCMetadataMiddleware.js';
+import MongoStore from 'connect-mongo';
+import { YogaServerInstance } from 'graphql-yoga';
+import { mongodb } from '@unchainedshop/mongodb';
+import { UnchainedCore } from '@unchainedshop/core';
+import { emit } from '@unchainedshop/events';
+import { API_EVENTS } from '../events.js';
+import { User } from '@unchainedshop/core-users';
+import { IncomingMessage } from 'http';
+import fastifySession from '@fastify/session';
+import fastifyCookie from '@fastify/cookie';
+
+const resolveUserRemoteAddress = (req: IncomingMessage) => {
+  const remoteAddress =
+    (req.headers['x-real-ip'] as string) ||
+    (req.headers['x-forwarded-for'] as string) ||
+    req.socket?.remoteAddress;
+
+  const remotePort = req.socket?.remotePort;
+
+  return { remoteAddress, remotePort };
+};
+
+const {
+  GRAPHQL_API_PATH = '/graphql',
+  UNCHAINED_COOKIE_NAME = 'unchained_token',
+  UNCHAINED_COOKIE_PATH = '/',
+  UNCHAINED_COOKIE_DOMAIN,
+  NODE_ENV,
+} = process.env;
+
+const middlewareHook = async function middlewareHook(req: any, reply: any) {
+  const setHeader = (key, value) => reply.header(key, value);
+  const getHeader = (key) => req.headers[key];
+  const { remoteAddress, remotePort } = resolveUserRemoteAddress(req);
+
+  const context = getCurrentContextResolver();
+
+  async function login(user: User) {
+    req.session.user = user;
+    req.session.userId = user._id;
+    const tokenObject = {
+      _id: req.session.sessionId,
+      /* eslint-disable-next-line */
+      tokenExpires: new Date((req as any).session?.cookie._expires),
+    };
+    await emit(API_EVENTS.API_LOGIN_TOKEN_CREATED, { userId: user._id, ...tokenObject });
+    /* eslint-disable-next-line */
+    (user as any)._inLoginMethodResponse = true;
+    return { user, ...tokenObject };
+  }
+
+  async function logout() {
+    /* eslint-disable-line */
+    if (!req.session?.userId) return false;
+    const tokenObject = {
+      _id: (req as any).session.sessionId,
+      userId: req.session?.userId,
+    };
+    req.session.user = null;
+    req.session.userId = null;
+    await emit(API_EVENTS.API_LOGOUT, tokenObject);
+    return true;
+  }
+
+  (req as any).unchainedContext = await context({
+    setHeader,
+    getHeader,
+    remoteAddress,
+    remotePort,
+    login,
+    logout,
+    user: req.session.user,
+    userId: req.session.userId,
+  });
+};
+
+export const connect = (
+  fastify: any,
+  {
+    graphqlHandler,
+    db,
+  }: { graphqlHandler: YogaServerInstance<any, any>; db: mongodb.Db; unchainedAPI: UnchainedCore },
+) => {
+  fastify.register(fastifyCookie);
+  fastify.register(fastifySession, {
+    secret: process.env.UNCHAINED_TOKEN_SECRET,
+    cookieName: UNCHAINED_COOKIE_NAME,
+    store: MongoStore.create({
+      client: (db as any).client,
+      dbName: db.databaseName,
+      collectionName: 'sessions',
+    }),
+    cookie: {
+      domain: UNCHAINED_COOKIE_DOMAIN,
+      httpOnly: Boolean(NODE_ENV === 'production'),
+      path: UNCHAINED_COOKIE_PATH,
+      secure: NODE_ENV === 'production',
+      maxAge: 1000 * 60 * 60 * 24 * 7,
+    },
+  });
+
+  fastify.decorateRequest('unchainedContext');
+  fastify.addHook('onRequest', middlewareHook);
+
+  fastify.route({
+    url: GRAPHQL_API_PATH,
+    method: ['GET', 'POST', 'OPTIONS'],
+    handler: async (req, reply) => {
+      // Second parameter adds Fastify's `req` and `reply` to the GraphQL Context
+      const response = await graphqlHandler.handleNodeRequestAndResponse(req, reply, {
+        req,
+        reply,
+      });
+      response.headers.forEach((value, key) => {
+        reply.header(key, value);
+      });
+      reply.status(response.status);
+      reply.send(response.body);
+      return reply;
+    },
+  });
+
+  //   expressApp.use(ERC_METADATA_API_PATH, createERCMetadataMiddleware);
+  //   expressApp.use(BULK_IMPORT_API_PATH, createBulkImportMiddleware);
+};

package/src/loaders/index.ts

@@ -1,14 +1,11 @@
 import DataLoader from 'dataloader';
 import { systemLocale } from '@unchainedshop/utils';
-import localePkg from 'locale';
-import { UnchainedCore } from '@unchainedshop/types/core.js';
+import { UnchainedCore } from '@unchainedshop/core';
 import { ProductStatus } from '@unchainedshop/core-products';
-import { UnchainedLoaders } from '@unchainedshop/types/api.js';
+import { UnchainedLoaders } from '../types.js';
 
-const { Locale } = localePkg;
-
-function getLocaleStrings(localeObj) {
-  return [localeObj.normalized, localeObj.language, systemLocale.normalized, systemLocale.language];
+function getLocaleStrings(localeObj: Intl.Locale) {
+  return [localeObj.baseName, localeObj.language, systemLocale.baseName, systemLocale.language];
 }
 
 function findMatchingText(texts, localeStrings) {
@@ -20,7 +17,7 @@ function findMatchingText(texts, localeStrings) {
 
 function getFilteredQueries({ queries, texts, filterFn }) {
   return queries.map(({ locale, ...queryParams }) => {
-    const localeObj = new Locale(locale);
+    const localeObj = new Intl.Locale(locale);
 
     const filteredTexts = texts.filter(filterFn(queryParams));
     if (!filteredTexts.length) return null;

package/src/locale-context.ts

@@ -1,5 +1,3 @@
-import { UnchainedLocaleContext, UnchainedHTTPServerContext } from '@unchainedshop/types/api.js';
-import localePkg from 'locale';
 import { log, LogLevel } from '@unchainedshop/logger';
 import {
   resolveBestCountry,
@@ -7,10 +5,9 @@ import {
   resolveBestCurrency,
   systemLocale,
 } from '@unchainedshop/utils';
-import { UnchainedCore } from '@unchainedshop/types/core.js';
+import { UnchainedCore } from '@unchainedshop/core';
 import memoizee from 'memoizee';
-
-const { Locales } = localePkg;
+import { UnchainedHTTPServerContext, UnchainedLocaleContext } from './types.js';
 
 const { NODE_ENV } = process.env;
 
@@ -30,22 +27,24 @@ export const resolveDefaultContext = memoizee(
 
     const currencies = await unchainedAPI.modules.currencies.findCurrencies({ includeInactive: false });
 
-    const supportedLocaleStrings = languages.reduce((accumulator, language) => {
+    const supportedLocaleStrings: Array<string> = languages.reduce((accumulator, language) => {
       const added = countries.map((country) => {
         return `${language.isoCode}-${country.isoCode}`;
       });
       return accumulator.concat(added);
     }, []);
 
-    const supportedLocales = new Locales(supportedLocaleStrings, systemLocale.code);
-
-    const localeContext = resolveBestSupported(acceptLang, supportedLocales);
-    const countryContext = resolveBestCountry(localeContext.country, acceptCountry, countries);
+    const localeContext = resolveBestSupported(
+      acceptLang,
+      supportedLocaleStrings,
+      systemLocale.baseName,
+    );
+    const countryContext = resolveBestCountry(localeContext.region, acceptCountry, countries);
 
     const countryObject = countries.find((country) => country.isoCode === countryContext);
     const currencyContext = resolveBestCurrency(countryObject.defaultCurrencyCode, currencies);
 
-    log(`Locale Context: Resolved ${localeContext.normalized} ${countryContext} ${currencyContext}`, {
+    log(`Locale Context: Resolved ${localeContext.baseName} ${countryContext} ${currencyContext}`, {
       level: LogLevel.Debug,
     });
 

package/src/resolvers/index.ts

@@ -1,4 +1,10 @@
-import { JSONResolver, TimestampResolver, DateTimeResolver, DateResolver } from 'graphql-scalars';
+import {
+  GraphQLJSON,
+  GraphQLTimestamp,
+  GraphQLDateTimeISO,
+  GraphQLDate,
+  GraphQLLocale,
+} from 'graphql-scalars';
 import Query from './queries/index.js';
 import Mutation from './mutations/index.js';
 import Types from './type/index.js';
@@ -7,10 +13,11 @@ import CustomScalars from './scalars/index.js';
 export default {
   ...Types,
   ...CustomScalars,
-  JSON: JSONResolver,
+  JSON: GraphQLJSON,
   Query,
   Mutation,
-  DateTime: DateTimeResolver,
-  Date: DateResolver,
-  Timestamp: TimestampResolver,
+  DateTime: GraphQLDateTimeISO,
+  Date: GraphQLDate,
+  Timestamp: GraphQLTimestamp,
+  Locale: GraphQLLocale,
 } as unknown as Record<string, any>;

package/src/resolvers/mutations/accounts/addEmail.ts

@@ -1,9 +1,9 @@
 import { log } from '@unchainedshop/logger';
-import { Context, Root } from '@unchainedshop/types/api.js';
 import { EmailAlreadyExistsError, UserNotFoundError } from '../../../errors.js';
+import { Context } from '../../../types.js';
 
 export default async function addEmail(
-  root: Root,
+  root: never,
   params: { email: string; userId?: string },
   { modules, userId }: Context,
 ) {

package/src/resolvers/mutations/accounts/addWeb3Address.ts

@@ -1,9 +1,9 @@
 import { log } from '@unchainedshop/logger';
-import { Context, Root } from '@unchainedshop/types/api.js';
 import { UserWeb3InvalidAddressError } from '../../../errors.js';
+import { Context } from '../../../types.js';
 
 export default async function addWeb3Address(
-  root: Root,
+  root: never,
   { address }: { address: any },
   { modules, userId, user }: Context,
 ) {

package/src/resolvers/mutations/accounts/addWebAuthnCredentials.ts

@@ -1,8 +1,8 @@
 import { log } from '@unchainedshop/logger';
-import { Context, Root } from '@unchainedshop/types/api.js';
+import { Context } from '../../../types.js';
 
 export default async function addWebAuthnCredentials(
-  root: Root,
+  root: never,
   { credentials }: { credentials: any },
   { modules, userId, user }: Context,
 ) {

package/src/resolvers/mutations/accounts/changePassword.ts

@@ -1,9 +1,9 @@
 import { log } from '@unchainedshop/logger';
-import { Context, Root } from '@unchainedshop/types/api.js';
 import { InvalidCredentialsError, PasswordInvalidError } from '../../../errors.js';
+import { Context } from '../../../types.js';
 
 export default async function changePassword(
-  root: Root,
+  root: never,
   params: {
     oldPassword?: string;
     newPassword?: string;