@ethersphere/bee-js 13.1.0 → 13.1.1-upcoming.g334b531

package/README.md

@@ -69,7 +69,7 @@ types. Where `NumberString` is present, `number` is disallowed in order to avoid
 ### Byte primitives
 
 All the classes below extend `Bytes`, therefore the following methods are available on all of them: `toUint8Array`,
-`toHex`, `toBase64`, `toBase32`, `toUtf8`, `toJSON`, `static keccak256`, `static fromUtf8`.
+`toHex`, `toBase64`, `toBase32`, `toUtf8`, `parsePayloadAsJson`, `static keccak256`, `static fromUtf8`.
 
 The `toString` method uses `toHex`.
 
@@ -337,8 +337,7 @@ const uploadResult = await bee.collection.uploadFromDirectory(batchId, './path/t
 ### Rolling feed (periodically-restarting sequential feed)
 
 A rolling feed avoids the unbounded growth of a plain sequential feed by restarting it every
-`periodLength` seconds, so old postage-batch eviction never breaks the latest update. See
-[ROLLING_FEED.md](./ROLLING_FEED.md) for the full design.
+`periodLength` seconds, so old postage-batch eviction never breaks the latest update.
 
 A rolling feed only stays readable while the writer keeps publishing. Keeping it alive is the
 application's job, not the SDK's, so a writer belongs on a timer — republish on every tick, even

package/dist/cjs/manifest/manifest.js

@@ -46,6 +46,7 @@ async function loadRecursively(node, bee, options, requestOptions) {
         const loaded = core_sdk_1.MantarayNode.unmarshalFromData(data, fork.node.selfAddress);
         fork.node.targetAddress = loaded.targetAddress;
         fork.node.forks = loaded.forks;
+        fork.node.obfuscationKey = loaded.obfuscationKey;
         fork.node.path = fork.prefix;
         fork.node.parent = node;
         await loadRecursively(fork.node, bee, options, requestOptions);

package/dist/codemod/transforms/v13.js

@@ -171,14 +171,19 @@ const METHOD_MAP = {
 function transform(sourceFile, checker) {
     const source = sourceFile.text;
     const isNewBee = (node) => !!node && ts.isNewExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === 'Bee';
-    // Does the type annotation mention `Bee` (`Bee`, `Bee | null`, `Bee | undefined`, …)?
+    const typeNameText = (name) => (ts.isIdentifier(name) ? name.text : name.right.text);
+    // Does the type annotation mention `Bee`, plain or wrapped (`Bee | null`, `Mocked<Bee>`,
+    // `jest.Mocked<Bee> & Extra`, …)? Arrays and tuples are left out — they don't expose Bee's members.
     const typeMentionsBee = (type) => {
         if (!type)
             return false;
-        if (ts.isTypeReferenceNode(type) && ts.isIdentifier(type.typeName) && type.typeName.text === 'Bee')
-            return true;
-        if (ts.isUnionTypeNode(type))
+        if (ts.isParenthesizedTypeNode(type))
+            return typeMentionsBee(type.type);
+        if (ts.isUnionTypeNode(type) || ts.isIntersectionTypeNode(type))
             return type.types.some(typeMentionsBee);
+        if (ts.isTypeReferenceNode(type)) {
+            return typeNameText(type.typeName) === 'Bee' || (type.typeArguments ?? []).some(typeMentionsBee);
+        }
         return false;
     };
     // Syntactic pass — identify Bee bindings from annotations and `new Bee(...)` alone, so
@@ -214,10 +219,17 @@ function transform(sourceFile, checker) {
         ts.forEachChild(node, collect);
     };
     collect(sourceFile);
+    const isBeeJsFile = (file) => /[/\\]bee-js[/\\]/.test(file) || /[/\\]bee\.(d\.)?ts$/.test(file);
+    // A wrapper type (`Mocked<Bee>`, `Partial<Bee>`, …) has no Bee symbol of its own, but the
+    // members it maps over still point back at the Bee class they came from.
+    const hasBeeMember = (type, memberName) => (type.getProperty(memberName)?.getDeclarations() ?? []).some(decl => {
+        const parent = decl.parent;
+        return (ts.isClassDeclaration(parent) && parent.name?.text === 'Bee' && isBeeJsFile(parent.getSourceFile().fileName));
+    });
     // A receiver is a Bee if identified syntactically (above) OR resolved by the type checker
     // to the `Bee` class declared by bee-js — the latter additionally catches imported/shared
-    // instances and factory calls (`getBee()`) when the project's types resolve.
-    const isBeeReceiver = (expr) => {
+    // instances, factory calls (`getBee()`) and mock wrappers when the project's types resolve.
+    const isBeeReceiver = (expr, memberName) => {
         if (ts.isIdentifier(expr) && beeNames.has(expr.text))
             return true;
         if (ts.isPropertyAccessExpression(expr) &&
@@ -225,17 +237,14 @@ function transform(sourceFile, checker) {
             beeFields.has(expr.name.text)) {
             return true;
         }
-        const symbol = checker.getTypeAtLocation(expr).getSymbol();
+        const type = checker.getTypeAtLocation(expr);
+        if (memberName && hasBeeMember(type, memberName))
+            return true;
+        const symbol = type.getSymbol();
         if (!symbol || symbol.getName() !== 'Bee') {
             return false;
         }
-        return (symbol.getDeclarations() ?? []).some(decl => {
-            if (!ts.isClassDeclaration(decl)) {
-                return false;
-            }
-            const file = decl.getSourceFile().fileName;
-            return /[/\\]bee-js[/\\]/.test(file) || /[/\\]bee\.(d\.)?ts$/.test(file);
-        });
+        return (symbol.getDeclarations() ?? []).some(decl => ts.isClassDeclaration(decl) && isBeeJsFile(decl.getSourceFile().fileName));
     };
     // ChunkBuilder.hash() now returns a Reference, not a raw Uint8Array.
     const isChunkBuilderReceiver = (expr) => {
@@ -434,7 +443,7 @@ function transform(sourceFile, checker) {
         // Any `<bee>.<method>` access — called or not — so bare method references migrate too.
         if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.name)) {
             const mapping = METHOD_MAP[node.name.text];
-            if (mapping && isBeeReceiver(node.expression)) {
+            if (mapping && isBeeReceiver(node.expression, node.name.text)) {
                 // Preserve optional chaining on the receiver: `bee?.uploadData` → `bee?.data.upload`.
                 const separator = node.questionDotToken ? '?.' : '.';
                 replacements.push({
@@ -468,7 +477,7 @@ function transform(sourceFile, checker) {
                         text: `${quote}${mapping.newName}${quote}`,
                     });
                 }
-                else if (mapping && isBeeReceiver(receiverArg)) {
+                else if (mapping && isBeeReceiver(receiverArg, methodArg.text)) {
                     replacements.push({
                         start: receiverArg.getStart(sourceFile),
                         end: receiverArg.getEnd(),