@unchainedshop/core-warehousing 3.0.0-alpha7 → 3.0.0-rc2

package/package.json

@@ -1,16 +1,13 @@
 {
   "name": "@unchainedshop/core-warehousing",
-  "version": "3.0.0-alpha7",
+  "version": "3.0.0-rc2",
   "main": "lib/warehousing-index.js",
-  "exports": {
-    ".": "./lib/warehousing-index.js",
-    "./*": "./lib/*"
-  },
   "types": "lib/warehousing-index.d.ts",
   "type": "module",
   "scripts": {
-    "clean": "rm -rf lib",
-    "prepublishOnly": "npm run clean && tsc",
+    "clean": "tsc -b --clean",
+    "build": "tsc -b",
+    "prepublishOnly": "npm run clean && npm run build",
     "watch": "tsc -w",
     "test": "NODE_OPTIONS=--experimental-vm-modules jest --detectOpenHandles --forceExit",
     "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch --detectOpenHandles --forceExit"
@@ -31,14 +28,14 @@
   },
   "homepage": "https://github.com/unchainedshop/unchained#readme",
   "dependencies": {
-    "@unchainedshop/events": "^3.0.0-alpha4",
-    "@unchainedshop/logger": "^3.0.0-alpha4",
-    "@unchainedshop/utils": "^3.0.0-alpha4"
+    "@unchainedshop/events": "^3.0.0-rc2",
+    "@unchainedshop/logger": "^3.0.0-rc2",
+    "@unchainedshop/utils": "^3.0.0-rc2"
   },
   "devDependencies": {
-    "@types/node": "^22.8.1",
+    "@types/node": "^22.10.2",
     "jest": "^29.7.0",
     "ts-jest": "^29.2.5",
-    "typescript": "^5.6.3"
+    "typescript": "^5.7.2"
   }
 }

package/src/db/TokenSurrogateCollection.ts

@@ -1,5 +1,25 @@
 import { mongodb, buildDbIndexes } from '@unchainedshop/mongodb';
-import { TokenSurrogate } from '../types.js';
+
+export type TokenSurrogate = {
+  _id?: string;
+  userId?: string;
+  walletAddress?: string;
+  invalidatedDate?: Date;
+  expiryDate?: Date;
+  quantity: number;
+  contractAddress: string;
+  chainId: string;
+  chainTokenId: string;
+  productId: string;
+  orderPositionId: string;
+  meta: any;
+};
+
+export enum TokenStatus {
+  CENTRALIZED = 'CENTRALIZED',
+  EXPORTING = 'EXPORTING',
+  DECENTRALIZED = 'DECENTRALIZED',
+}
 
 export const TokenSurrogateCollection = async (db: mongodb.Db) => {
   const TokenSurrogates = db.collection<TokenSurrogate>('token_surrogates');

package/src/db/WarehousingProvidersCollection.ts

@@ -1,5 +1,18 @@
-import { mongodb, buildDbIndexes } from '@unchainedshop/mongodb';
-import { WarehousingProvider } from '../types.js';
+import { mongodb, buildDbIndexes, TimestampFields } from '@unchainedshop/mongodb';
+
+export enum WarehousingProviderType {
+  PHYSICAL = 'PHYSICAL',
+  VIRTUAL = 'VIRTUAL',
+}
+
+export type WarehousingConfiguration = Array<{ key: string; value: string }>;
+
+export type WarehousingProvider = {
+  _id?: string;
+  type: WarehousingProviderType;
+  adapterKey: string;
+  configuration: WarehousingConfiguration;
+} & TimestampFields;
 
 export const WarehousingProvidersCollection = async (db: mongodb.Db) => {
   const WarehousingProviders = db.collection<WarehousingProvider>('warehousing-providers');

package/src/module/buildFindSelector.test.ts

@@ -1,4 +1,4 @@
-import { WarehousingProviderType } from '../warehousing-index.js';
+import { WarehousingProviderType } from '../db/WarehousingProvidersCollection.js';
 import { buildFindSelector } from './configureWarehousingModule.js';
 
 describe('Warehousing', () => {

package/src/module/configureWarehousingModule.ts

@@ -1,102 +1,14 @@
-import type { User } from '@unchainedshop/core-users';
-
-import { UnchainedCore } from '@unchainedshop/core';
+import { emit, registerEvents } from '@unchainedshop/events';
+import { generateDbFilterById, generateDbObjectId, mongodb, ModuleInput } from '@unchainedshop/mongodb';
 import {
-  WarehousingContext,
   WarehousingProvider,
-  WarehousingProviderQuery,
+  WarehousingProvidersCollection,
   WarehousingProviderType,
-} from '../types.js';
-import { emit, registerEvents } from '@unchainedshop/events';
-import { generateDbFilterById, generateDbObjectId, mongodb, ModuleInput } from '@unchainedshop/mongodb';
-import { WarehousingProvidersCollection } from '../db/WarehousingProvidersCollection.js';
-import { WarehousingDirector } from '../director/WarehousingDirector.js';
-import { TokenSurrogateCollection } from '../db/TokenSurrogateCollection.js';
-import { EstimatedDispatch, EstimatedStock, TokenSurrogate, WarehousingInterface } from '../types.js';
-import { WarehousingError } from '../warehousing-index.js';
-import { Order } from '@unchainedshop/core-orders';
-import { OrderPosition } from '@unchainedshop/core-orders';
-import { Product } from '@unchainedshop/core-products';
-
-export type WarehousingModule = {
-  // Queries
-  findProvider: (
-    query: { warehousingProviderId: string },
-    options?: mongodb.FindOptions,
-  ) => Promise<WarehousingProvider>;
-  findToken: (query: { tokenId: string }, options?: mongodb.FindOptions) => Promise<TokenSurrogate>;
-  findTokensForUser: (user: User, options?: mongodb.FindOptions) => Promise<Array<TokenSurrogate>>;
-  findTokens: (query: any, options?: mongodb.FindOptions) => Promise<Array<TokenSurrogate>>;
-  findProviders: (
-    query: WarehousingProviderQuery,
-    options?: mongodb.FindOptions,
-  ) => Promise<Array<WarehousingProvider>>;
-  count: (query: WarehousingProviderQuery) => Promise<number>;
-  providerExists: (query: { warehousingProviderId: string }) => Promise<boolean>;
-
-  // Adapter
-
-  findSupported: (
-    warehousingContext: WarehousingContext,
-    unchainedAPI: UnchainedCore,
-  ) => Promise<Array<WarehousingProvider>>;
-  findInterface: (query: WarehousingProvider) => WarehousingInterface;
-  findInterfaces: (query: WarehousingProviderQuery) => Array<WarehousingInterface>;
-  configurationError: (
-    provider: WarehousingProvider,
-    unchainedAPI: UnchainedCore,
-  ) => Promise<WarehousingError>;
-  isActive: (provider: WarehousingProvider, unchainedAPI: UnchainedCore) => Promise<boolean>;
-
-  estimatedDispatch: (
-    provider: WarehousingProvider,
-    context: WarehousingContext,
-    unchainedAPI: UnchainedCore,
-  ) => Promise<EstimatedDispatch>;
-
-  estimatedStock: (
-    provider: WarehousingProvider,
-    context: WarehousingContext,
-    unchainedAPI: UnchainedCore,
-  ) => Promise<EstimatedStock>;
-
-  updateTokenOwnership: (input: {
-    tokenId: string;
-    userId: string;
-    walletAddress: string;
-  }) => Promise<void>;
-
-  invalidateToken: (tokenId: string) => Promise<void>;
-
-  buildAccessKeyForToken: (tokenId: string) => Promise<string>;
-
-  tokenizeItems: (
-    order: Order,
-    params: {
-      items: Array<{
-        orderPosition: OrderPosition;
-        product: Product;
-      }>;
-    },
-    unchainedAPI: UnchainedCore,
-  ) => Promise<void>;
-
-  tokenMetadata: (
-    chainTokenId: string,
-    params: { product: Product; token: TokenSurrogate; referenceDate: Date; locale: Intl.Locale },
-    unchainedAPI: UnchainedCore,
-  ) => Promise<any>;
+} from '../db/WarehousingProvidersCollection.js';
+import { TokenSurrogate, TokenSurrogateCollection } from '../db/TokenSurrogateCollection.js';
 
-  isInvalidateable: (
-    chainTokenId: string,
-    params: { product: Product; token: TokenSurrogate; referenceDate: Date },
-    unchainedAPI: UnchainedCore,
-  ) => Promise<boolean>;
-
-  // Mutations
-  delete: (providerId: string) => Promise<WarehousingProvider>;
-  update: (_id: string, doc: WarehousingProvider) => Promise<string>;
-  create: (doc: WarehousingProvider) => Promise<string | null>;
+type WarehousingProviderQuery = {
+  type?: WarehousingProviderType;
 };
 
 const WAREHOUSING_PROVIDER_EVENTS: string[] = [
@@ -112,15 +24,7 @@ export const buildFindSelector = ({ type }: WarehousingProviderQuery = {}) => {
   return query;
 };
 
-const asyncFilter = async (arr, predicate) => {
-  const results = await Promise.all(arr.map(predicate));
-
-  return arr.filter((_v, index) => results[index]);
-};
-
-export const configureWarehousingModule = async ({
-  db,
-}: ModuleInput<Record<string, never>>): Promise<WarehousingModule> => {
+export const configureWarehousingModule = async ({ db }: ModuleInput<Record<string, never>>) => {
   registerEvents(WAREHOUSING_PROVIDER_EVENTS);
 
   const WarehousingProviders = await WarehousingProvidersCollection(db);
@@ -128,49 +32,68 @@ export const configureWarehousingModule = async ({
 
   return {
     // Queries
-    count: async (query) => {
+    count: async (query: WarehousingProviderQuery): Promise<number> => {
       const providerCount = await WarehousingProviders.countDocuments(buildFindSelector(query));
       return providerCount;
     },
 
-    findProvider: async ({ warehousingProviderId }, options) => {
+    createTokens: async (tokens: TokenSurrogate[]): Promise<void> => {
+      await TokenSurrogates.insertMany(tokens);
+    },
+
+    findProvider: async (
+      { warehousingProviderId }: { warehousingProviderId: string },
+      options?: mongodb.FindOptions,
+    ): Promise<WarehousingProvider> => {
       return WarehousingProviders.findOne(generateDbFilterById(warehousingProviderId), options);
     },
 
-    findToken: async ({ tokenId }, options) => {
-      return TokenSurrogates.findOne(generateDbFilterById(tokenId), options);
+    findToken: async (
+      { tokenId }: { tokenId: string },
+      options?: mongodb.FindOptions,
+    ): Promise<TokenSurrogate> => {
+      return TokenSurrogates.findOne({ _id: tokenId }, options);
     },
 
-    findTokens: async (selector, options) => {
+    findTokens: async (selector: any, options?: mongodb.FindOptions): Promise<Array<TokenSurrogate>> => {
       return TokenSurrogates.find(selector, options).toArray();
     },
 
-    findTokensForUser: async (user, options) => {
-      const addresses =
-        user.services?.web3?.flatMap((service) => {
-          return service.verified ? [service.address] : [];
-        }) || [];
+    findTokensForUser: async (
+      params: { userId: string } | { walletAddresses: string[] },
+      options?: mongodb.FindOptions,
+    ): Promise<Array<TokenSurrogate>> => {
+      const { userId, walletAddresses } = params as any;
+      if (!userId && !walletAddresses)
+        throw new Error('userId or walletAddresses must be provided for findTokensForUser');
       const selector = {
         $or: [
-          {
-            walletAddress: { $in: addresses || [] },
+          walletAddresses && {
+            walletAddress: { $in: walletAddresses || [] },
           },
-          {
-            userId: user._id,
+          userId && {
+            userId,
           },
-        ],
+        ].filter(Boolean),
       };
 
       const userTokens = await TokenSurrogates.find(selector, options).toArray();
       return userTokens;
     },
 
-    findProviders: async (query, options = { sort: { created: 1 } }) => {
+    findProviders: async (
+      query: WarehousingProviderQuery,
+      options: mongodb.FindOptions = { sort: { created: 1 } },
+    ): Promise<Array<WarehousingProvider>> => {
       const providers = WarehousingProviders.find(buildFindSelector(query), options);
       return providers.toArray();
     },
 
-    providerExists: async ({ warehousingProviderId }) => {
+    providerExists: async ({
+      warehousingProviderId,
+    }: {
+      warehousingProviderId: string;
+    }): Promise<boolean> => {
       const providerCount = await WarehousingProviders.countDocuments(
         generateDbFilterById(warehousingProviderId, { deleted: null }),
         { limit: 1 },
@@ -178,63 +101,15 @@ export const configureWarehousingModule = async ({
       return !!providerCount;
     },
 
-    // Adapter
-
-    findInterface: (warehousingProvider) => {
-      const Adapter = WarehousingDirector.getAdapter(warehousingProvider.adapterKey);
-      if (!Adapter) return null;
-      return {
-        _id: Adapter.key,
-        label: Adapter.label,
-        version: Adapter.version,
-      };
-    },
-
-    findInterfaces: ({ type }) => {
-      return WarehousingDirector.getAdapters({
-        adapterFilter: (Adapter) => Adapter.typeSupported(type),
-      }).map((Adapter) => ({
-        _id: Adapter.key,
-        label: Adapter.label,
-        version: Adapter.version,
-      }));
-    },
-
-    findSupported: async (warehousingContext, unchainedAPI) => {
-      const allProviders = await WarehousingProviders.find(buildFindSelector({})).toArray();
-
-      const providers = asyncFilter(allProviders, async (provider) => {
-        const director = await WarehousingDirector.actions(provider, warehousingContext, unchainedAPI);
-        return director.isActive();
-      });
-
-      return providers;
-    },
-
-    configurationError: async (warehousingProvider, unchainedAPI) => {
-      const actions = await WarehousingDirector.actions(warehousingProvider, {}, unchainedAPI);
-      return actions.configurationError();
-    },
-
-    estimatedDispatch: async (warehousingProvider, warehousingContext, unchainedAPI) => {
-      const director = await WarehousingDirector.actions(
-        warehousingProvider,
-        warehousingContext,
-        unchainedAPI,
-      );
-      return director.estimatedDispatch();
-    },
-
-    estimatedStock: async (warehousingProvider, warehousingContext, unchainedAPI) => {
-      const director = await WarehousingDirector.actions(
-        warehousingProvider,
-        warehousingContext,
-        unchainedAPI,
-      );
-      return director.estimatedStock();
-    },
-
-    updateTokenOwnership: async ({ tokenId, userId, walletAddress }) => {
+    updateTokenOwnership: async ({
+      tokenId,
+      userId,
+      walletAddress,
+    }: {
+      tokenId: string;
+      userId: string;
+      walletAddress: string;
+    }): Promise<TokenSurrogate> => {
       const token = await TokenSurrogates.findOneAndUpdate(
         { _id: tokenId },
         {
@@ -246,100 +121,10 @@ export const configureWarehousingModule = async ({
         { returnDocument: 'after' },
       );
       await emit('TOKEN_OWNERSHIP_CHANGED', { token });
+      return token;
     },
 
-    tokenizeItems: async (order, { items }, unchainedAPI) => {
-      const virtualProviders = await WarehousingProviders.find(
-        buildFindSelector({ type: WarehousingProviderType.VIRTUAL }),
-      ).toArray();
-
-      const tokenizers = await Promise.all(
-        items.flatMap(({ orderPosition, product }) => {
-          const warehousingContext: WarehousingContext = {
-            order,
-            orderPosition,
-            product,
-            quantity: orderPosition.quantity,
-            referenceDate: order.ordered,
-          };
-          return virtualProviders.map(async (provider) => {
-            const director = await WarehousingDirector.actions(
-              provider,
-              warehousingContext,
-              unchainedAPI,
-            );
-            const isActive = await director.isActive();
-            if (isActive) return director.tokenize;
-            return (async () => []) as typeof director.tokenize;
-          });
-        }),
-      );
-
-      // Tokenize linearly so that after every tokenized item, the db is updated
-      await tokenizers.reduce(async (lastPromise, tokenizer) => {
-        await lastPromise;
-        const tokenSurrogates = await tokenizer();
-        await TokenSurrogates.insertMany(tokenSurrogates);
-        return true;
-      }, Promise.resolve(false));
-    },
-
-    tokenMetadata: async (chainTokenId, { token, product, locale, referenceDate }, unchainedAPI) => {
-      const virtualProviders = await WarehousingProviders.find(
-        buildFindSelector({ type: WarehousingProviderType.VIRTUAL }),
-      ).toArray();
-
-      const warehousingContext: WarehousingContext = {
-        product,
-        token,
-        locale,
-        quantity: token?.quantity || 1,
-        referenceDate,
-      };
-      return virtualProviders.reduce(async (lastPromise, provider) => {
-        const last = await lastPromise;
-        if (last) return last;
-        const currentDirector = await WarehousingDirector.actions(
-          provider,
-          warehousingContext,
-          unchainedAPI,
-        );
-        const isActive = await currentDirector.isActive();
-        if (isActive) {
-          return currentDirector.tokenMetadata(chainTokenId);
-        }
-        return null;
-      }, Promise.resolve(null));
-    },
-
-    isInvalidateable: async (chainTokenId, { token, product, referenceDate }, unchainedAPI) => {
-      const virtualProviders = await WarehousingProviders.find(
-        buildFindSelector({ type: WarehousingProviderType.VIRTUAL }),
-      ).toArray();
-
-      const warehousingContext: WarehousingContext = {
-        product,
-        token,
-        quantity: token?.quantity || 1,
-        referenceDate,
-      };
-      return virtualProviders.reduce(async (lastPromise, provider) => {
-        const last = await lastPromise;
-        if (last) return last;
-        const currentDirector = await WarehousingDirector.actions(
-          provider,
-          warehousingContext,
-          unchainedAPI,
-        );
-        const isActive = await currentDirector.isActive();
-        if (isActive) {
-          return currentDirector.isInvalidateable(chainTokenId);
-        }
-        return null;
-      }, Promise.resolve(null));
-    },
-
-    invalidateToken: async (tokenId) => {
+    invalidateToken: async (tokenId: string): Promise<TokenSurrogate> => {
       const token = await TokenSurrogates.findOneAndUpdate(
         { _id: tokenId, invalidatedDate: null },
         {
@@ -354,9 +139,10 @@ export const configureWarehousingModule = async ({
       if (token) {
         await emit('TOKEN_INVALIDATED', { token });
       }
+      return token;
     },
 
-    buildAccessKeyForToken: async (tokenId) => {
+    buildAccessKeyForToken: async (tokenId: string): Promise<string> => {
       const token = await TokenSurrogates.findOne(generateDbFilterById(tokenId));
       const payload = [
         token._id,
@@ -371,33 +157,22 @@ export const configureWarehousingModule = async ({
       return hashHex;
     },
 
-    isActive: async (warehousingProvider, unchainedAPI) => {
-      const actions = await WarehousingDirector.actions(warehousingProvider, {}, unchainedAPI);
-      return actions.isActive();
-    },
-
     // Mutations
-    create: async (doc) => {
-      const Adapter = WarehousingDirector.getAdapter(doc.adapterKey);
-      if (!Adapter) return null;
-
+    create: async (doc: WarehousingProvider): Promise<WarehousingProvider> => {
       const { insertedId: warehousingProviderId } = await WarehousingProviders.insertOne({
         _id: generateDbObjectId(),
         created: new Date(),
-        configuration: Adapter.initialConfiguration,
         ...doc,
       });
 
-      const warehousingProvider = await WarehousingProviders.findOne(
-        generateDbFilterById(warehousingProviderId),
-      );
+      const warehousingProvider = await WarehousingProviders.findOne({ _id: warehousingProviderId });
       await emit('WAREHOUSING_PROVIDER_CREATE', { warehousingProvider });
-      return warehousingProviderId;
+      return warehousingProvider;
     },
 
     update: async (warehousingProviderId: string, doc: WarehousingProvider) => {
       const warehousingProvider = await WarehousingProviders.findOneAndUpdate(
-        generateDbFilterById(warehousingProviderId),
+        { _id: warehousingProviderId },
         {
           $set: {
             updated: new Date(),
@@ -410,10 +185,10 @@ export const configureWarehousingModule = async ({
       if (!warehousingProvider) return null;
 
       await emit('WAREHOUSING_PROVIDER_UPDATE', { warehousingProvider });
-      return warehousingProviderId;
+      return warehousingProvider;
     },
 
-    delete: async (providerId) => {
+    delete: async (providerId: string): Promise<WarehousingProvider> => {
       const warehousingProvider = await WarehousingProviders.findOneAndUpdate(
         generateDbFilterById(providerId),
         {
@@ -425,8 +200,9 @@ export const configureWarehousingModule = async ({
       );
 
       await emit('WAREHOUSING_PROVIDER_REMOVE', { warehousingProvider });
-
       return warehousingProvider;
     },
   };
 };
+
+export type WarehousingModule = Awaited<ReturnType<typeof configureWarehousingModule>>;

package/src/warehousing-index.ts

@@ -1,7 +1,3 @@
-export * from './types.js';
 export * from './module/configureWarehousingModule.js';
-
-export { WarehousingDirector } from './director/WarehousingDirector.js';
-export { WarehousingAdapter } from './director/WarehousingAdapter.js';
-export { WarehousingError } from './director/WarehousingError.js';
-export { WarehousingProviderType } from './director/WarehousingProviderType.js';
+export * from './db/TokenSurrogateCollection.js';
+export * from './db/WarehousingProvidersCollection.js';

package/tsconfig.json

@@ -1,11 +1,9 @@
 {
   "extends": "../shared/base.tsconfig.json",
   "compilerOptions": {
-    "rootDir": "src",
-    "outDir": "lib",
+    "declarationDir": "./lib",
+    "rootDir": "./src",
+    "outDir": "./lib"
   },
-  "exclude": ["**/*.test.ts", "**/*.test.js", "tests"],
-  "include": [
-    "./src"
-  ]
-}
+  "exclude": ["**/*.test.ts", "**/*.test.js", "tests", "lib"]
+}

package/src/director/WarehousingAdapter.ts

@@ -1,39 +0,0 @@
-import { IWarehousingAdapter } from '../types.js';
-import { log, LogLevel } from '@unchainedshop/logger';
-
-import { WarehousingError } from './WarehousingError.js';
-
-export const WarehousingAdapter: Omit<IWarehousingAdapter, 'key' | 'label' | 'version'> = {
-  orderIndex: 0,
-
-  typeSupported: () => {
-    return false;
-  },
-
-  initialConfiguration: [],
-
-  actions: () => {
-    return {
-      configurationError: () => WarehousingError.NOT_IMPLEMENTED,
-
-      isActive: () => false,
-
-      stock: async () => 0,
-
-      productionTime: async () => 0,
-
-      commissioningTime: async () => 0,
-
-      tokenize: async () => [],
-
-      tokenMetadata: async () => ({}),
-
-      isInvalidateable: async () => true,
-    };
-  },
-
-  log(message, { level = LogLevel.Debug, ...options } = {}) {
-    // eslint-disable-line
-    return log(message, { level, ...options });
-  },
-};