Merge pull request #237 from DestinyItemManager/fix-armor-hash

Fix exotic armor hash type, again

Author: bhollis

api/stately/generated/index_pb.d.ts

@@ -482,9 +482,9 @@ export declare type LoadoutParameters = Message<"stately.generated.LoadoutParame
   assumeArmorMasterwork: AssumeArmorMasterwork;
 
   /**
-   * @generated from field: int32 exoticArmorHash = 11;
+   * @generated from field: int64 exoticArmorHash = 11;
    */
-  exoticArmorHash: number;
+  exoticArmorHash: bigint;
 
   /**
    * @generated from field: stately.generated.InGameLoadoutIdentifiers inGameIdentifiers = 12;

api/stately/generated/index_pb.js

@@ -8,7 +8,7 @@ import { enumDesc, fileDesc, messageDesc, tsEnum } from "@bufbuild/protobuf/code
  * Describes the file index.proto.
  */
 export const file_index = /*@__PURE__*/
-  fileDesc("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");
+  fileDesc("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");
 
 /**
  * Describes the message stately.generated.ApiApp.

api/stately/loadouts-queries.test.ts

@@ -1,8 +1,13 @@
+import { toBinary } from '@bufbuild/protobuf';
 import _ from 'lodash';
 import { v4 as uuid } from 'uuid';
-import { Loadout } from '../shapes/loadouts.js';
+import { defaultLoadoutParameters, Loadout, LoadoutParameters } from '../shapes/loadouts.js';
+import { client } from './client.js';
+import { LoadoutParametersSchema, LoadoutSchema } from './generated/index.js';
 import {
   convertLoadoutFromStately,
+  convertLoadoutParametersFromStately,
+  convertLoadoutParametersToStately,
   convertLoadoutToStately,
   deleteAllLoadouts,
   deleteLoadout,
@@ -41,12 +46,43 @@ export const loadout: Loadout = {
 
 it('can roundtrip between DIM loadout and Stately loadout', () => {
   const statelyLoadout = convertLoadoutToStately(loadout, platformMembershipId, 2);
+  expect(() => toBinary(LoadoutSchema, statelyLoadout)).not.toThrow();
   const loadout2 = convertLoadoutFromStately(statelyLoadout);
   expect(_.omit(loadout2, 'profileId', 'destinyVersion', 'createdAt', 'lastUpdatedAt')).toEqual(
     loadout,
   );
 });
 
+it('can roundtrip loadout parameters', () => {
+  const loParams: LoadoutParameters = {
+    ...defaultLoadoutParameters,
+    exoticArmorHash: 3045642045,
+  };
+
+  const statelyLoParams = client.create(
+    'LoadoutParameters',
+    convertLoadoutParametersToStately(loParams),
+  );
+  expect(() => toBinary(LoadoutParametersSchema, statelyLoParams)).not.toThrow();
+  const loParams2 = convertLoadoutParametersFromStately(statelyLoParams);
+  expect(loParams2).toEqual(loParams);
+});
+
+it('can roundtrip loadout parameters w/ a negative armor hash', () => {
+  const loParams: LoadoutParameters = {
+    ...defaultLoadoutParameters,
+    exoticArmorHash: -1,
+  };
+
+  const statelyLoParams = client.create(
+    'LoadoutParameters',
+    convertLoadoutParametersToStately(loParams),
+  );
+  expect(() => toBinary(LoadoutParametersSchema, statelyLoParams)).not.toThrow();
+  const loParams2 = convertLoadoutParametersFromStately(statelyLoParams);
+  expect(loParams2).toEqual(loParams);
+});
+
 it('can record a loadout', async () => {
   await updateLoadout(platformMembershipId, 2, loadout);
 

api/stately/loadouts-queries.ts

@@ -136,6 +136,8 @@ export function convertLoadoutParametersFromStately(
     stripTypeName(loParameters);
   return {
     ...stripDefaults(loParametersDefaulted),
+    exoticArmorHash:
+      loParameters.exoticArmorHash === 0n ? undefined : Number(loParameters.exoticArmorHash),
     // DIM's AssumArmorMasterwork enum starts at 1
     assumeArmorMasterwork: (assumeArmorMasterwork ?? 0) + 1,
     statConstraints: statConstraintsFromStately(statConstraints),
@@ -271,10 +273,16 @@ export function convertLoadoutParametersToStately(
 ): MessageInitShape<typeof LoadoutParametersSchema> | undefined {
   let loParametersFixed: MessageInitShape<typeof LoadoutParametersSchema> | undefined;
   if (!_.isEmpty(loParameters)) {
-    const { assumeArmorMasterwork, statConstraints, modsByBucket, ...loParametersDefaulted } =
-      loParameters;
+    const {
+      assumeArmorMasterwork,
+      exoticArmorHash,
+      statConstraints,
+      modsByBucket,
+      ...loParametersDefaulted
+    } = loParameters;
     loParametersFixed = {
       ...loParametersDefaulted,
+      exoticArmorHash: BigInt(exoticArmorHash ?? 0),
       statConstraints: statConstraintsToStately(statConstraints),
       // DIM's AssumArmorMasterwork enum starts at 1
       assumeArmorMasterwork: Number(assumeArmorMasterwork ?? AssumeArmorMasterwork.None) - 1,