chore: add PR CI, bump deploy Action versions, drop unused ts-node, test price script

- Add a pull_request-triggered CI workflow (lint/test/build) so PRs are
  checked before merge, including the automated price-update PRs.
- Bump actions/checkout and actions/setup-node to v4 in the deploy workflow
  for consistency with the price-update workflow.
- Remove the unused ts-node devDependency now that scripts run via tsx.
- Split scripts/update-prices.ts into testable price-utils.ts and
  device-consts-ast.ts modules, with unit tests covering price parsing,
  the currency sanity check, and the ts-morph AST read/write logic.

Author: andy23512

.github/workflows/ci.yml

@@ -0,0 +1,28 @@
+name: CI
+
+on:
+  pull_request:
+
+jobs:
+  lint-test-build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Use Node.js 20.x
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20.x
+
+      - name: Install dependencies
+        run: yarn
+
+      - name: Lint
+        run: yarn nx lint
+
+      - name: Test
+        run: yarn test
+
+      - name: Build
+        run: yarn build

.github/workflows/main.yml

@@ -15,10 +15,10 @@ jobs:
         # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
 
       - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v2
+        uses: actions/setup-node@v4
         with:
           node-version: ${{ matrix.node-version }}
 

.yarn/install-state.gz

@@ -22,5 +22,6 @@ export default {
   testMatch: [
     '<rootDir>/src/**/__tests__/**/*.[jt]s?(x)',
     '<rootDir>/src/**/*(*.)@(spec|test).[jt]s?(x)',
+    '<rootDir>/scripts/**/*(*.)@(spec|test).[jt]s?(x)',
   ],
 };

jest.config.ts

@@ -64,7 +64,6 @@
     "prettier": "^3.4.2",
     "ts-jest": "^29.1.0",
     "ts-morph": "^28.0.0",
-    "ts-node": "10.9.1",
     "tsx": "^4.23.13",
     "typescript": "~5.5.2"
   },

package.json

@@ -0,0 +1,77 @@
+import { Project } from 'ts-morph';
+
+import {
+  findDeviceObjectLiteral,
+  getPriceProperty,
+  parseCommittedPrice,
+} from './device-consts-ast';
+
+const SAMPLE_SOURCE = `
+export const CCX = {
+  key: 'ccx',
+  other: {
+    price: 99.99,
+  },
+};
+
+export const M4G = {
+  key: 'm4g',
+  other: {
+    price: { type: 'number-range', value: { min: 599.99, max: 749.99 } },
+  },
+};
+
+export const CCU = {
+  key: 'ccu',
+  other: {
+    price: 'N/A',
+  },
+};
+`;
+
+function createSourceFile() {
+  const project = new Project({ useInMemoryFileSystem: true });
+  return project.createSourceFile('device.consts.ts', SAMPLE_SOURCE);
+}
+
+describe('findDeviceObjectLiteral', () => {
+  it('finds the object literal declared with the matching key', () => {
+    const sourceFile = createSourceFile();
+    const deviceObject = findDeviceObjectLiteral(sourceFile, 'ccx');
+    expect(deviceObject.getProperty('key')?.getText()).toBe("key: 'ccx'");
+  });
+
+  it('throws when no device has the given key', () => {
+    const sourceFile = createSourceFile();
+    expect(() => findDeviceObjectLiteral(sourceFile, 'does-not-exist')).toThrow(
+      /was not found/,
+    );
+  });
+});
+
+describe('getPriceProperty / parseCommittedPrice', () => {
+  it('parses a plain numeric price', () => {
+    const sourceFile = createSourceFile();
+    const property = getPriceProperty(sourceFile, 'ccx');
+    expect(parseCommittedPrice(property)).toBe(99.99);
+  });
+
+  it('parses a number-range price', () => {
+    const sourceFile = createSourceFile();
+    const property = getPriceProperty(sourceFile, 'm4g');
+    expect(parseCommittedPrice(property)).toEqual({ min: 599.99, max: 749.99 });
+  });
+
+  it('returns null for a placeholder like N/A', () => {
+    const sourceFile = createSourceFile();
+    const property = getPriceProperty(sourceFile, 'ccu');
+    expect(parseCommittedPrice(property)).toBeNull();
+  });
+
+  it('reflects a written price back after setInitializer', () => {
+    const sourceFile = createSourceFile();
+    const property = getPriceProperty(sourceFile, 'ccx');
+    property.setInitializer('149.99');
+    expect(parseCommittedPrice(property)).toBe(149.99);
+  });
+});

scripts/device-consts-ast.spec.ts

@@ -0,0 +1,89 @@
+import {
+  Node,
+  ObjectLiteralExpression,
+  Project,
+  PropertyAssignment,
+  SourceFile,
+} from 'ts-morph';
+
+import { PriceValue } from './price-utils';
+
+export function getObjectProperty(
+  obj: ObjectLiteralExpression,
+  name: string,
+): PropertyAssignment {
+  const prop = obj.getProperty(name);
+  if (!prop || !Node.isPropertyAssignment(prop)) {
+    throw new Error(`Property "${name}" was not found on object literal`);
+  }
+  return prop;
+}
+
+export function findDeviceObjectLiteral(
+  sourceFile: SourceFile,
+  deviceKey: string,
+): ObjectLiteralExpression {
+  const deviceObject = sourceFile
+    .getVariableDeclarations()
+    .map((declaration) => declaration.getInitializer())
+    .find(
+      (initializer): initializer is ObjectLiteralExpression =>
+        Node.isObjectLiteralExpression(initializer) &&
+        getObjectProperty(initializer, 'key').getInitializer()?.getText() ===
+          `'${deviceKey}'`,
+    );
+  if (!deviceObject) {
+    throw new Error(`Device with key "${deviceKey}" was not found`);
+  }
+  return deviceObject;
+}
+
+export function getPriceProperty(
+  sourceFile: SourceFile,
+  deviceKey: string,
+): PropertyAssignment {
+  const deviceObject = findDeviceObjectLiteral(sourceFile, deviceKey);
+  const otherInitializer = getObjectProperty(
+    deviceObject,
+    'other',
+  ).getInitializer();
+  if (!otherInitializer || !Node.isObjectLiteralExpression(otherInitializer)) {
+    throw new Error(
+      `"other" property on device "${deviceKey}" is not an object literal`,
+    );
+  }
+  return getObjectProperty(otherInitializer, 'price');
+}
+
+// Parses the currently-committed price back into a PriceValue, or null if
+// it's currently a placeholder like 'N/A' / '???' with no numeric baseline.
+export function parseCommittedPrice(
+  priceProperty: PropertyAssignment,
+): PriceValue | null {
+  const initializer = priceProperty.getInitializer();
+  if (!initializer) {
+    return null;
+  }
+  if (Node.isNumericLiteral(initializer)) {
+    return initializer.getLiteralValue();
+  }
+  if (Node.isObjectLiteralExpression(initializer)) {
+    const valueInitializer = getObjectProperty(
+      initializer,
+      'value',
+    ).getInitializer();
+    if (valueInitializer && Node.isObjectLiteralExpression(valueInitializer)) {
+      const min = getObjectProperty(valueInitializer, 'min').getInitializer();
+      const max = getObjectProperty(valueInitializer, 'max').getInitializer();
+      if (min && max && Node.isNumericLiteral(min) && Node.isNumericLiteral(max)) {
+        return { min: min.getLiteralValue(), max: max.getLiteralValue() };
+      }
+    }
+  }
+  return null;
+}
+
+export function loadSourceFile(filePath: string): SourceFile {
+  const project = new Project();
+  return project.addSourceFileAtPath(filePath);
+}

scripts/device-consts-ast.ts

@@ -0,0 +1,141 @@
+import {
+  assertPriceIsReasonable,
+  computePrices,
+  getVariantPrice,
+  priceLiteralText,
+  ShopifyProduct,
+} from './price-utils';
+
+describe('getVariantPrice', () => {
+  const products: ShopifyProduct[] = [
+    {
+      handle: 'charachorder-x',
+      variants: [{ title: 'Default Title', price: '99.99' }],
+    },
+    {
+      handle: 'master-forge-1',
+      variants: [
+        { title: 'Standard', price: '599.99' },
+        { title: 'Premium', price: '749.99' },
+      ],
+    },
+  ];
+
+  it('returns the price of the only variant when no title is given', () => {
+    expect(getVariantPrice(products, 'charachorder-x')).toBe(99.99);
+  });
+
+  it('returns the price of the matching variant title', () => {
+    expect(getVariantPrice(products, 'master-forge-1', 'Premium')).toBe(749.99);
+  });
+
+  it('throws when the product handle is not found', () => {
+    expect(() => getVariantPrice(products, 'does-not-exist')).toThrow(
+      /was not found/,
+    );
+  });
+
+  it('throws when the variant title is not found', () => {
+    expect(() =>
+      getVariantPrice(products, 'master-forge-1', 'does-not-exist'),
+    ).toThrow(/was not found/);
+  });
+
+  it('throws when the price is not a valid number', () => {
+    const badProducts: ShopifyProduct[] = [
+      { handle: 'broken', variants: [{ title: 'Default', price: 'n/a' }] },
+    ];
+    expect(() => getVariantPrice(badProducts, 'broken')).toThrow(
+      /not a valid number/,
+    );
+  });
+});
+
+describe('computePrices', () => {
+  it('computes single prices and ranges from Shopify product data', () => {
+    const charachorderProducts: ShopifyProduct[] = [
+      {
+        handle: 'master-forge-1',
+        variants: [{ title: 'Default Title', price: '599.99' }],
+      },
+      {
+        handle: 'master-forge-premium',
+        variants: [{ title: 'Default Title', price: '749.99' }],
+      },
+      { handle: 'cc2', variants: [{ title: 'Default Title', price: '249.99' }] },
+      {
+        handle: 'charachorder-lite',
+        variants: [{ title: 'Default Title', price: '149.99' }],
+      },
+      {
+        handle: 'charachorder-x',
+        variants: [{ title: 'Default Title', price: '99.99' }],
+      },
+    ];
+    const svalboardProducts: ShopifyProduct[] = [
+      {
+        handle: 'lightly',
+        variants: [
+          { title: 'No Pointer', price: '800' },
+          { title: 'Dual Pointer', price: '1050' },
+        ],
+      },
+    ];
+
+    expect(computePrices(charachorderProducts, svalboardProducts)).toEqual({
+      m4g: { min: 599.99, max: 749.99 },
+      'cc2-1': 249.99,
+      cclite: 149.99,
+      ccx: 99.99,
+      sval: { min: 800, max: 1050 },
+    });
+  });
+});
+
+describe('priceLiteralText', () => {
+  it('renders a plain number', () => {
+    expect(priceLiteralText(99.99)).toBe('99.99');
+  });
+
+  it('renders a number range as a device-spec object literal', () => {
+    expect(priceLiteralText({ min: 599.99, max: 749.99 })).toBe(
+      "{ type: 'number-range', value: { min: 599.99, max: 749.99 } }",
+    );
+  });
+});
+
+describe('assertPriceIsReasonable', () => {
+  it('does not throw when there is no committed price to compare against', () => {
+    expect(() =>
+      assertPriceIsReasonable('sval', null, { min: 800, max: 1050 }),
+    ).not.toThrow();
+  });
+
+  it('does not throw when the fresh price is close to the committed price', () => {
+    expect(() =>
+      assertPriceIsReasonable('ccx', 99.99, 104.99),
+    ).not.toThrow();
+  });
+
+  it('throws when the fresh price is a currency-localized outlier', () => {
+    expect(() => assertPriceIsReasonable('m4g', 599.99, 19263)).toThrow(
+      /sanity check failed/,
+    );
+  });
+
+  it('throws when the fresh price is implausibly small', () => {
+    expect(() => assertPriceIsReasonable('ccx', 99.99, 1)).toThrow(
+      /sanity check failed/,
+    );
+  });
+
+  it('checks both ends of a price range', () => {
+    expect(() =>
+      assertPriceIsReasonable(
+        'm4g',
+        { min: 599.99, max: 749.99 },
+        { min: 599.99, max: 24079 },
+      ),
+    ).toThrow(/sanity check failed/);
+  });
+});