@unchainedshop/api 4.3.5 → 4.4.0

package/lib/schema/types/product/product.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"product.js","sourceRoot":"","sources":["../../../../src/schema/types/product/product.ts"],"names":[],"mappings":"AAAA,eAAe;IACb,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwIb;CACF,CAAC"}

package/lib/schema/types/product/simple-product.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"simple-product.d.ts","sourceRoot":"","sources":["../../../../src/schema/types/product/simple-product.ts"],"names":[],"mappings":";AAAA,wBAuDE"}

package/lib/schema/types/product/simple-product.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"simple-product.js","sourceRoot":"","sources":["../../../../src/schema/types/product/simple-product.ts"],"names":[],"mappings":"AAAA,eAAe;IACb,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDb;CACF,CAAC"}

package/lib/schema/types/product/tokenized-product.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tokenized-product.d.ts","sourceRoot":"","sources":["../../../../src/schema/types/product/tokenized-product.ts"],"names":[],"mappings":";AAAA,wBAiEE"}

package/lib/schema/types/product/tokenized-product.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tokenized-product.js","sourceRoot":"","sources":["../../../../src/schema/types/product/tokenized-product.ts"],"names":[],"mappings":"AAAA,eAAe;IACb,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+Db;CACF,CAAC"}

package/lib/schema/types/quotation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"quotation.d.ts","sourceRoot":"","sources":["../../../src/schema/types/quotation.ts"],"names":[],"mappings":";AAAA,wBA6DE"}

package/lib/schema/types/quotation.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"quotation.js","sourceRoot":"","sources":["../../../src/schema/types/quotation.ts"],"names":[],"mappings":"AAAA,eAAe;IACb,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2Db;CACF,CAAC"}

package/lib/schema/types/search.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../src/schema/types/search.ts"],"names":[],"mappings":";AAAA,wBA+BE"}

package/lib/schema/types/search.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"search.js","sourceRoot":"","sources":["../../../src/schema/types/search.ts"],"names":[],"mappings":"AAAA,eAAe;IACb,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6Bb;CACF,CAAC"}

package/lib/schema/types/shop.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shop.d.ts","sourceRoot":"","sources":["../../../src/schema/types/shop.ts"],"names":[],"mappings":";AAAA,wBA0CE"}

package/lib/schema/types/shop.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"shop.js","sourceRoot":"","sources":["../../../src/schema/types/shop.ts"],"names":[],"mappings":"AAAA,eAAe;IACb,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCb;CACF,CAAC"}

package/lib/schema/types/stock.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stock.d.ts","sourceRoot":"","sources":["../../../src/schema/types/stock.ts"],"names":[],"mappings":";AAAA,wBAQE"}

package/lib/schema/types/stock.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"stock.js","sourceRoot":"","sources":["../../../src/schema/types/stock.ts"],"names":[],"mappings":"AAAA,eAAe;IACb,aAAa,CAAC;;;;;;GAMb;CACF,CAAC"}

package/lib/schema/types/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/schema/types/types.ts"],"names":[],"mappings":";AAAA,wBAWE"}

package/lib/schema/types/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/schema/types/types.ts"],"names":[],"mappings":"AAAA,eAAe;IACb,aAAa,CAAC;;;;;;;;;GASb;CACF,CAAC"}

package/lib/schema/types/user.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"user.d.ts","sourceRoot":"","sources":["../../../src/schema/types/user.ts"],"names":[],"mappings":";AAAA,wBA6IE"}

package/lib/schema/types/user.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"user.js","sourceRoot":"","sources":["../../../src/schema/types/user.ts"],"names":[],"mappings":"AAAA,eAAe;IACb,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2Ib;CACF,CAAC"}

package/lib/schema/types/warehousing.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"warehousing.d.ts","sourceRoot":"","sources":["../../../src/schema/types/warehousing.ts"],"names":[],"mappings":";AAAA,wBAgEE"}

package/lib/schema/types/warehousing.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"warehousing.js","sourceRoot":"","sources":["../../../src/schema/types/warehousing.ts"],"names":[],"mappings":"AAAA,eAAe;IACb,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8Db;CACF,CAAC"}

package/lib/schema/types/worker.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../../src/schema/types/worker.ts"],"names":[],"mappings":";AAAA,wBA0EE"}

package/lib/schema/types/worker.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"worker.js","sourceRoot":"","sources":["../../../src/schema/types/worker.ts"],"names":[],"mappings":"AAAA,eAAe;IACb,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwEb;CACF,CAAC"}

package/lib/user-context.d.ts

@@ -1,7 +0,0 @@
-import { IncomingMessage, OutgoingMessage } from 'http';
-import { UnchainedUserContext } from '@unchainedshop/types/api.js';
-import { UnchainedCore } from '@unchainedshop/types/core.js';
-export declare const getUserContext: (req: IncomingMessage & {
-    cookies?: any;
-}, res: OutgoingMessage, unchainedAPI: UnchainedCore) => Promise<UnchainedUserContext>;
-//# sourceMappingURL=user-context.d.ts.map

package/lib/user-context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"user-context.d.ts","sourceRoot":"","sources":["../src/user-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,MAAM,CAAC;AACxD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AA0C7D,eAAO,MAAM,cAAc,QACpB,eAAe,GAAG;IAAE,OAAO,CAAC,EAAE,GAAG,CAAA;CAAE,OACnC,eAAe,gBACN,aAAa,KAC1B,OAAO,CAAC,oBAAoB,CAsD9B,CAAC"}

package/lib/user-context.js

@@ -1,76 +0,0 @@
-import cookie from 'cookie';
-function isString(input) {
-    return typeof input === 'string' && Object.prototype.toString.call(input) === '[object String]';
-}
-const { UNCHAINED_COOKIE_NAME = 'unchained_token', UNCHAINED_COOKIE_PATH = '/', UNCHAINED_COOKIE_DOMAIN, UNCHAINED_COOKIE_SAMESITE, UNCHAINED_COOKIE_INSECURE, } = process.env;
-function setLoginToken(res, token, expires) {
-    const cookieName = UNCHAINED_COOKIE_NAME;
-    const domain = UNCHAINED_COOKIE_DOMAIN;
-    const path = UNCHAINED_COOKIE_PATH;
-    const secure = UNCHAINED_COOKIE_INSECURE ? false : true;
-    const sameSite = ({
-        none: 'none',
-        lax: 'lax',
-        strict: 'strict',
-        '1': true,
-        '0': false,
-    }[UNCHAINED_COOKIE_SAMESITE?.trim()?.toLowerCase()] || false);
-    if (!cookieName)
-        return;
-    const authCookie = cookie.serialize(cookieName, token || null, {
-        domain,
-        httpOnly: true,
-        path,
-        expires: token && expires ? expires : undefined,
-        maxAge: token ? undefined : -1,
-        sameSite,
-        secure,
-    });
-    res.setHeader('Set-Cookie', authCookie);
-}
-export const getUserContext = async (req, res, unchainedAPI) => {
-    // there is a possible current user connected!
-    const cookieName = UNCHAINED_COOKIE_NAME;
-    let loginToken = req.cookies?.[cookieName];
-    if (req.headers.authorization) {
-        const [type, token] = req.headers.authorization.split(' ');
-        if (type === 'Bearer') {
-            loginToken = token;
-        }
-    }
-    if (loginToken) {
-        // throw an error if the token is not a string
-        if (!isString(loginToken))
-            throw new Error('Access Token is not a string');
-        // the hashed token is the key to find the possible current user in the db
-        const hashedToken = unchainedAPI.modules.accounts.createHashLoginToken(loginToken);
-        const currentUser = await unchainedAPI.modules.users.findUserByToken({
-            hashedToken,
-        });
-        // the current user exists
-        if (currentUser) {
-            // find the right login token corresponding, the current user may have
-            // several sessions logged on different browsers / computers
-            const tokenInformation = currentUser.services.resume.loginTokens.find((tokenInfo) => tokenInfo.hashedToken === hashedToken); // eslint-disable-line
-            // true if the token is expired
-            const isExpired = new Date(tokenInformation.when) < new Date();
-            // if the token is still valid, give access to the current user
-            // information in the resolvers context
-            if (!isExpired) {
-                // return a new context object with the current user & her id
-                return {
-                    user: currentUser,
-                    userId: currentUser._id,
-                    loginToken: loginToken,
-                    setLoginToken,
-                };
-            }
-        }
-        // If there is no user with this token or the token is expires/invalid,
-        // we should remove that cookie from the client
-        setLoginToken(res, null);
-        return { loginToken: loginToken, setLoginToken };
-    }
-    return { setLoginToken };
-};
-//# sourceMappingURL=user-context.js.map

package/lib/user-context.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"user-context.js","sourceRoot":"","sources":["../src/user-context.ts"],"names":[],"mappings":"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"}

package/src/acl.ts

@@ -1,96 +0,0 @@
-import { CheckPermissionArgs } from '@unchainedshop/roles';
-import { Roles } from '@unchainedshop/roles';
-import { NoPermissionError, PermissionSystemError } from './errors.js';
-
-const defaultOptions = {
-  showKey: true,
-  mapArgs: (...args) => args,
-};
-
-const emptyObject = {};
-const emptyArray: CheckPermissionArgs = [];
-
-export const ensureActionExists = (action, userOptions) => {
-  if (!action) {
-    throw new PermissionSystemError({ userOptions });
-  }
-};
-
-export const ensureIsFunction = (fn, action, options, key) => {
-  if (typeof fn !== 'function') {
-    throw new PermissionSystemError({
-      action,
-      key: options.showKey ? key : '',
-    });
-  }
-};
-
-const checkAction = async (context, action, args = emptyArray, options: any = emptyObject) => {
-  const { key } = options || emptyObject;
-
-  const hasPermission = await Roles.userHasPermission(context, action, args);
-  if (hasPermission) return;
-
-  const keyText = key && key !== '' ? ` in "${key}"` : '';
-
-  throw new NoPermissionError({
-    userId: context.userId,
-    action,
-    key,
-    message: `The user "${
-      context.userId || 'anonymous'
-    }" has no permission to perform the action "${action}"${keyText}`,
-  });
-};
-
-const wrapFunction = (fn, name, action, userOptions?: any) => {
-  const key = name || fn.name;
-  const options = { ...defaultOptions, ...userOptions };
-  ensureIsFunction(fn, action, options, key);
-  return async (root, params, context, ...other) => {
-    const args = options.mapArgs(root, params, ...other);
-    await checkAction(context, action, args, {
-      key: options.showKey ? key : '',
-    });
-    return fn(root, params, context, ...other);
-  };
-};
-
-const checkResolver = (action, userOptions?: any) => {
-  ensureActionExists(action, userOptions);
-  return (fn: any, name?: string) => wrapFunction(fn, name, action, userOptions);
-};
-
-const checkTypeResolver = (action, key) =>
-  async function _checkTypeResolver(obj, params, context) {
-    await checkAction(context, action, [obj, params]);
-    if (typeof obj[key] === 'function') {
-      return obj[key](params, context);
-    }
-    return obj[key];
-  };
-
-const resolverDecorator = function resolverDecorator(action, userOptions?: any) {
-  ensureActionExists(action, userOptions);
-  return function decorator(target, key, descriptor) {
-    const fn = descriptor.value || target[key];
-    return {
-      configurable: true,
-      get() {
-        const value = wrapFunction(fn, key, action, userOptions);
-        Object.defineProperty(this, key, {
-          value,
-          configurable: true,
-          writable: true,
-        });
-        return value;
-      },
-    };
-  };
-};
-
-// @resolverDecorator(action)
-// resolverToBeChecked: () => ...
-export default resolverDecorator;
-
-export { resolverDecorator, checkResolver, checkTypeResolver, checkAction };

package/src/api-index.ts

@@ -1,65 +0,0 @@
-import createGraphQLServer, { GraphQLServerOptions } from './createGraphQLServer.js';
-import {
-  createContextResolver,
-  setCurrentContextResolver,
-  getCurrentContextResolver,
-  AdminUiConfig,
-  UnchainedContextResolver,
-} from './context.js';
-import { UnchainedCore } from '@unchainedshop/core';
-export * from './events.js';
-export * from './context.js';
-export * from './locale-context.js';
-export * from './loaders/index.js';
-export * from './errors.js';
-export * as acl from './acl.js';
-export * as roles from './roles/index.js';
-export { createContextResolver, getCurrentContextResolver, setCurrentContextResolver };
-
-import { buildDefaultTypeDefs } from './schema/index.js';
-import resolvers from './resolvers/index.js';
-import { actions } from './roles/index.js';
-
-export type UnchainedServerOptions = {
-  roles?: any;
-  adminUiConfig?: AdminUiConfig;
-  unchainedAPI: UnchainedCore;
-  context?: (defaultResolver: UnchainedContextResolver) => UnchainedContextResolver;
-} & Partial<GraphQLServerOptions>;
-
-export const startAPIServer = async (options: UnchainedServerOptions) => {
-  const {
-    unchainedAPI,
-    context: customContext,
-    roles,
-    adminUiConfig = {},
-    ...serverOptions
-  } = options as UnchainedServerOptions;
-
-  const contextResolver = createContextResolver(unchainedAPI, {
-    roles,
-    adminUiConfig,
-  });
-
-  setCurrentContextResolver(
-    customContext
-      ? (props, ...rest) => {
-          return customContext(contextResolver)(props, ...rest);
-        }
-      : contextResolver,
-  );
-
-  const additionalTypeDefs = 'typeDefs' in serverOptions ? serverOptions.typeDefs : [];
-  const additionalResolvers = 'resolvers' in serverOptions ? serverOptions.resolvers : [];
-
-  return createGraphQLServer({
-    ...serverOptions,
-    typeDefs: [
-      ...buildDefaultTypeDefs({
-        actions: Object.keys(actions),
-      }),
-      ...(additionalTypeDefs || []),
-    ],
-    resolvers: [resolvers, ...(additionalResolvers || [])],
-  });
-};

package/src/chat/defaultSystemPrompt.ts

@@ -1,16 +0,0 @@
-const defaultSystemPrompt = `YOU MUST FOLLOW THIS RULE: After ANY tool execution, output NOTHING. No text. No explanation. No "done". Just STOP. Tool results are shown automatically.
-
-ONLY output text when:
-1. No tools were called this turn, OR
-2. User explicitly asks "explain" or "why"
-
-    Rules for using the Unchained MCP tools:
-    - All prices are integer type and to correctly determine the currency decimal points check the currencies resource.
-    - CRITICAL: Available languages, currencies, and countries are provided as MCP RESOURCES (unchained://shop/languages, unchained://shop/currencies, unchained://shop/countries). You MUST check these resources FIRST - DO NOT use localization_management tools with LIST action to check availability. The resources contain all available options.
-    - NEVER call localization_management with action LIST, GET, or COUNT to check if a language/currency/country exists. Use the resources instead.
-    - When validating localization codes, ONLY check against the resource data. If a code is not in the resources, it does not exist.
-    - If a user requests an operation with a non-existing language/currency/country, respond: "The [language/currency/country] '[code]' is not registered in the shop. Would you like me to add it first before proceeding?"
-    - If the user agrees, use localization_management with action: CREATE to add it, then proceed with the original operation.
-`;
-
-export default defaultSystemPrompt;

package/src/chat/generateImageHandler.ts

@@ -1,91 +0,0 @@
-import { z } from 'zod';
-import mime from 'mime/lite';
-import type * as aiTypes from 'ai';
-import { createLogger } from '@unchainedshop/logger';
-
-const logger = createLogger('unchained:api:mcp');
-
-let experimental_generateImage: typeof aiTypes.experimental_generateImage;
-let tool: typeof aiTypes.tool;
-
-try {
-  const aiTools = await import('ai');
-  tool = aiTools.tool;
-  experimental_generateImage = aiTools.experimental_generateImage;
-} catch {
-  /* */
-}
-
-const inputSchema = z.object({
-  prompt: z.string().describe('The prompt to generate the image from'),
-  size: z
-    .enum([
-      '512x512',
-      '768x768',
-      '1024x1024',
-      '512x896',
-      '640x1120',
-      '768x1344',
-      '1024x1792',
-      '896x512',
-      '1120x640',
-      '1344x768',
-      '1792x1024',
-    ])
-    .optional()
-    .describe('The size of the image (default is 1024x1024).'),
-});
-
-const generateImageHandler =
-  (req: any) =>
-  ({
-    model,
-    uploadUrl = `${process.env.ROOT_URL}/temp-upload`,
-  }: {
-    model: aiTypes.ImageModel;
-    uploadUrl?: string;
-  }) => {
-    return tool<any>({
-      description: 'Generate an image based on the prompt',
-      inputSchema: inputSchema as any,
-      name: 'generate_image',
-      execute: async ({ prompt, size = '1024x1024' }) => {
-        try {
-          const { image } = await experimental_generateImage({
-            model,
-            prompt,
-            size: size as any,
-          });
-
-          const buffer = Buffer.from(image.uint8Array);
-          const extension = mime.getExtension(image.mediaType) || 'png';
-
-          const filename = `image-${Date.now()}.${extension}`;
-          const file = new File([buffer], filename, { type: image.mediaType });
-          const formData = new FormData();
-          formData.append('image', file);
-
-          const uploadRes = await fetch(uploadUrl, {
-            method: 'POST',
-            body: formData,
-            credentials: 'include',
-            headers: {
-              Cookie: req?.headers?.cookie || req?.headers?.get('cookie') || '',
-            },
-          });
-
-          if (!uploadRes.ok) {
-            throw new Error(`Image upload failed: ${uploadRes.statusText}`);
-          }
-
-          const { url } = await uploadRes.json();
-          return { imageUrl: url, prompt };
-        } catch (error) {
-          logger.error('Error generating image:', (error as Error).message);
-          return `Error Generating image: ${(error as Error).message}`;
-        }
-      },
-    });
-  };
-
-export default generateImageHandler;

package/src/chat/normalizeToolsIndex.ts

@@ -1,11 +0,0 @@
-import { categorizeTools } from './utils.js';
-
-export default function normalizeToolsIndex(mcpTools: any) {
-  const tools = Object.entries(mcpTools).map(([name, tool]: any) => ({
-    name,
-    description: tool.description || '',
-    parameters: tool.parameters || {},
-    category: categorizeTools(name),
-  }));
-  return tools;
-}

package/src/chat/utils.ts

@@ -1,42 +0,0 @@
-import type * as aiTypes from 'ai';
-
-let NoSuchToolError: typeof aiTypes.NoSuchToolError;
-let InvalidArgumentError: typeof aiTypes.InvalidArgumentError;
-
-try {
-  const aiTools = await import('ai');
-  InvalidArgumentError = aiTools.InvalidArgumentError;
-  NoSuchToolError = aiTools.NoSuchToolError;
-} catch {
-  /* */
-}
-
-export type StreamTextParams = Parameters<typeof aiTypes.streamText>[0];
-
-export type ChatConfiguration = Omit<StreamTextParams, 'messages'> & {
-  unchainedMCPUrl?: string;
-  imageGenerationTool?: { model: aiTypes.ImageModel; uploadUrl?: string };
-};
-
-export const errorHandler = (error: any): string => {
-  if (NoSuchToolError.isInstance(error)) return 'NoSuchToolError';
-  if (InvalidArgumentError.isInstance(error)) return 'InvalidToolArgumentsError';
-  /* if (ToolExecutionError.isInstance(error)) return 'ToolExecutionError'; */
-  if (error?.message?.toLowerCase()?.includes('forbidden')) return 'NetworkError';
-  if (error?.message?.toLowerCase()?.includes('limit')) return 'LimitExceeded';
-  return `Failed to stream response: ${error?.message || 'Unknown error'}`;
-};
-
-export const categorizeTools = (toolName: string): string => {
-  const name = toolName.toLowerCase();
-
-  if (name.includes('product')) return 'Product Management';
-  if (name.includes('order')) return 'Order Management';
-  if (name.includes('customer') || name.includes('user')) return 'Customer Management';
-  if (name.includes('shop') || name.includes('settings')) return 'Shop Configuration';
-  if (name.includes('assortment')) return 'Assortments';
-  if (name.includes('filter')) return 'Filters';
-  if (name.includes('image') || name.includes('generate')) return 'Media & Content';
-
-  return 'Other Tools';
-};

package/src/context.ts

@@ -1,120 +0,0 @@
-import { UnchainedCore } from '@unchainedshop/core';
-import instantiateLoaders, { UnchainedLoaders } from './loaders/index.js';
-import { getLocaleContext, UnchainedLocaleContext } from './locale-context.js';
-import { UnchainedServerOptions } from './api-index.js';
-import { User } from '@unchainedshop/core-users';
-
-export type LoginFn = (
-  user: User,
-  options?: {
-    impersonator?: User;
-  },
-) => Promise<{ _id: string; tokenExpires: Date }>;
-
-export type LogoutFn = (sessionId?: string) => Promise<boolean>;
-export interface UnchainedUserContext {
-  login: LoginFn;
-  logout: LogoutFn;
-  userId?: string;
-  impersonatorId?: string;
-  accessToken?: string;
-  user?: User;
-}
-
-export interface CustomAdminUiProperties {
-  entityName: string;
-  inlineFragment: string;
-}
-
-export interface AdminUiConfig {
-  customProperties?: CustomAdminUiProperties[];
-  singleSignOnURL?: string;
-  defaultProductTags?: string[];
-  defaultAssortmentTags?: string[];
-  defaultUserTags?: string[];
-}
-
-export interface UnchainedHTTPServerContext {
-  setHeader: (key: string, value: string) => void;
-  getHeader: (key: string) => string;
-  remoteAddress?: string;
-  remotePort?: number;
-}
-
-export type Context = UnchainedCore & {
-  version?: string;
-  roles?: any;
-  adminUiConfig?: AdminUiConfig;
-  loaders: UnchainedLoaders;
-} & UnchainedUserContext &
-  UnchainedLocaleContext &
-  UnchainedHTTPServerContext;
-
-let context;
-
-export const getCurrentContextResolver = (): UnchainedContextResolver => context;
-
-export const setCurrentContextResolver = (newContext: UnchainedContextResolver) => {
-  context = newContext;
-};
-
-export type UnchainedContextResolver<Request = any, Response = any> = (
-  params: UnchainedHTTPServerContext & Omit<UnchainedUserContext, 'user'>,
-  req?: Request,
-  res?: Response,
-) => Promise<Context>;
-
-const { default: packageJson } = await import(`${import.meta.dirname}/../package.json`, {
-  with: { type: 'json' },
-});
-
-const { UNCHAINED_API_VERSION = packageJson?.version || process.env.npm_package_version || 'n/a' } =
-  process.env;
-
-export const createContextResolver =
-  (
-    unchainedAPI: UnchainedCore,
-    unchainedConfig: Pick<UnchainedServerOptions, 'roles' | 'adminUiConfig'>,
-  ): UnchainedContextResolver =>
-  async ({
-    getHeader,
-    setHeader,
-    remoteAddress,
-    remotePort,
-    userId,
-    impersonatorId,
-    accessToken,
-    login,
-    logout,
-  }) => {
-    const abstractHttpServerContext = { remoteAddress, remotePort, getHeader, setHeader };
-    const loaders = instantiateLoaders(unchainedAPI);
-    const localeContext = await getLocaleContext(abstractHttpServerContext, unchainedAPI);
-
-    const userContext: UnchainedUserContext = { login, logout, impersonatorId };
-
-    if (accessToken) {
-      const accessTokenUser = await unchainedAPI.modules.users.findUserByToken(accessToken);
-      if (accessTokenUser) {
-        userContext.user = accessTokenUser;
-        userContext.userId = accessTokenUser._id;
-      }
-    }
-    if (userId && !userContext.userId) {
-      const user = await unchainedAPI.modules.users.findUserById(userId);
-      if (user) {
-        userContext.user = user;
-        userContext.userId = user._id;
-      }
-    }
-
-    return {
-      ...unchainedAPI,
-      ...unchainedConfig,
-      ...localeContext,
-      ...userContext,
-      ...abstractHttpServerContext,
-      loaders,
-      version: UNCHAINED_API_VERSION,
-    };
-  };

package/src/createGraphQLServer.ts

@@ -1,33 +0,0 @@
-import { createLogger } from '@unchainedshop/logger';
-import { createYoga, createSchema, YogaServerOptions, YogaSchemaDefinition } from 'graphql-yoga';
-
-const logger = createLogger('unchained:api');
-
-export interface UnchainedSchemaExtension {
-  typeDefs: string[];
-  resolvers: Record<string, any>[];
-  schema?: YogaSchemaDefinition<any, any>;
-}
-
-export type GraphQLServerOptions = YogaServerOptions<any, any> & UnchainedSchemaExtension;
-
-export default async (options: GraphQLServerOptions) => {
-  const schema =
-    'schema' in options
-      ? options.schema
-      : createSchema({
-          typeDefs: options.typeDefs,
-          resolvers: options.resolvers,
-        });
-
-  const server = createYoga({
-    schema,
-    logging: logger,
-    context: async (ctx: any) => {
-      return (ctx.req as any)?.unchainedContext;
-    },
-    ...options,
-  });
-
-  return server;
-};