Add a robustier instanceof alternative to allow cross-package compatibility.

CHANGELOG.md

@@ -6,6 +6,9 @@ project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Unreleased
 
+### Fixed
+* Increase robustness of compatibility across multiple `js-xdr` instances in an environment ([#122](https://github.com/stellar/js-xdr/pull/122)).
+
 
 ## [v3.1.1](https://github.com/stellar/js-xdr/compare/v3.1.0...v3.1.1)
 

src/array.js

@@ -25,7 +25,7 @@ export class Array extends XdrCompositeType {
  * @inheritDoc
  */
  write(value, writer) {
- if (!(value instanceof global.Array))
+ if (!global.Array.isArray(value))
  throw new XdrWriterError(`value is not array`);
 
  if (value.length !== this._length)

src/enum.js

@@ -1,5 +1,5 @@
 import { Int } from './int';
-import { XdrPrimitiveType } from './xdr-type';
+import { XdrPrimitiveType, isSerializableIsh } from './xdr-type';
 import { XdrReaderError, XdrWriterError } from './errors';
 
 export class Enum extends XdrPrimitiveType {
@@ -26,7 +26,7 @@ export class Enum extends XdrPrimitiveType {
  * @inheritDoc
  */
  static write(value, writer) {
- if (!(value instanceof this))
+ if (!isSerializableIsh(value, Enum))
  throw new XdrWriterError(`unknown ${value} is not a ${this.enumName}`);
 
  Int.write(value.value, writer);

src/struct.js

@@ -1,5 +1,5 @@
 import { Reference } from './reference';
-import { XdrPrimitiveType } from './xdr-type';
+import { XdrPrimitiveType, isSerializableIsh } from './xdr-type';
 import { XdrWriterError } from './errors';
 
 export class Struct extends XdrPrimitiveType {
@@ -23,7 +23,7 @@ export class Struct extends XdrPrimitiveType {
  * @inheritDoc
  */
  static write(value, writer) {
- if (!(value instanceof this))
+ if (!isSerializableIsh(value, Struct))
  throw new XdrWriterError(`${value} is not a ${this.structName}`);
 
  for (const [fieldName, type] of this._fields) {

src/union.js

@@ -1,6 +1,6 @@
 import { Void } from './void';
 import { Reference } from './reference';
-import { XdrCompositeType } from './xdr-type';
+import { XdrCompositeType, isSerializableIsh } from './xdr-type';
 import { XdrWriterError } from './errors';
 
 export class Union extends XdrCompositeType {
@@ -81,8 +81,10 @@ export class Union extends XdrCompositeType {
  * @inheritDoc
  */
  static write(value, writer) {
- if (!(value instanceof this))
- throw new XdrWriterError(`${value} is not a ${this.unionName}`);
+ if (!isSerializableIsh(value, Union))
+ throw new XdrWriterError(
+ `${value} is ${value?.constructor?.name}, not ${this.unionName}`
+ );
 
  this._switchOn.write(value.switch(), writer);
  value.armType().write(value.value(), writer);

src/xdr-type.js

@@ -170,6 +170,48 @@ function decodeInput(input, format) {
  }
 }
 
+/**
+ * Provides a "duck typed" version of the native `instanceof` for read/write.
+ *
+ * "Duck typing" means if the parameter _looks like_ and _acts like_ a duck
+ * (i.e. the type we're checking), it will be treated as that type.
+ *
+ * In this case, the "type" we're looking for is "like XdrCompositeType",
+ * meaning serialization, but also conditioned on a particular subclass of
+ * "XdrCompositionType" (e.g. {@link Union} which extends XdrCompositeType ->
+ * XdrType).
+ *
+ * This makes the package resilient to downstream systems that may be combining
+ * many versions of a package across its stack that are technically compatible
+ * but fail `instanceof` checks due to cross-pollination.
+ */
+export function isSerializableIsh(value, subtype) {
+ const hasConstructor = (instance, name) => {
+ do {
+ if (instance.constructor.name === name) {
+ return true;
+ }
+ } while ((instance = Object.getPrototypeOf(instance)));
+ return false;
+ };
+
+ return (
+ value !== undefined &&
+ value !== null && // prereqs, otherwise `getPrototypeOf` pops
+ (value instanceof subtype || // quickest check
+ // Do an initial constructor check (anywhere is fine so that children of
+ // `subtype` still work), then
+ (hasConstructor(value, subtype) &&
+ // ensure it has read/write methods, then
+ typeof value.read === 'function' &&
+ typeof value.write === 'function' &&
+ // ensure XdrCompositeType is in the prototype chain (XdrCompositeType
+ // reliably gives us XdrType unless you're *intentionally* being weird,
+ // so skip checking for that).
+ hasConstructor(value, 'XdrCompositeType')))
+ );
+}
+
 /**
  * @typedef {'raw'|'hex'|'base64'} XdrEncodingFormat
  */

test/unit/xdr-type_test.js

@@ -0,0 +1,29 @@
+import { isSerializableIsh } from '../../src/xdr-type';
+import { Union } from '../../src/union';
+
+describe('duck-typing serialization', function () {
+ class XdrCompositeType {}
+ class Duck extends XdrCompositeType {
+ write() {}
+ read() {}
+ }
+ class Duckling extends Duck {}
+
+ it('respects ducks', function () {
+ expect(isSerializableIsh(new Duck(), XdrCompositeType)).to.be.true;
+ expect(isSerializableIsh(new Duck(), Duck)).to.be.true;
+ expect(isSerializableIsh(new Duckling(), Duck)).to.be.true;
+ expect(isSerializableIsh(new Duckling(), Duckling)).to.be.true;
+ });
+
+ class LiterateDuck extends XdrCompositeType {
+ read() {}
+ }
+ class Platypus extends LiterateDuck {}
+ it('does not respect non-ducks', function () {
+ expect(isSerializableIsh(new Platypus(), Duck)).to.be.false;
+ expect(isSerializableIsh(new Platypus(), XdrCompositeType)).to.be.true;
+ expect(isSerializableIsh(new LiterateDuck(), LiterateDuck)).to.be.true;
+ expect(isSerializableIsh(new Platypus(), Union)).to.be.false;
+ });
+});

webpack.config.js

@@ -38,10 +38,19 @@ module.exports = function () {
  };
  if (browserBuild) {
  config.optimization = {
- minimize: true,
+ minimize: false,
  minimizer: [
  new TerserPlugin({
- parallel: true
+ parallel: true,
+ terserOptions: {
+ reserved: [
+ 'XdrType',
+ 'XdrCompositeType',
+ 'Union',
+ 'Array',
+ 'Struct'
+ ]
+ }
  })
  ]
  };