🐛 fix(containers): replace tagPrecision with computed tagPinned for hide-pinned filter (#270)

- Add isTagPinned() in tag/precision.ts with rolling-tag alias detection
  (latest, stable, edge, nightly, etc.) so non-versioned tags are correctly
  treated as unpinned
- Add tagPinned computed property on Container model via defineProperty getter
- Separate store startup initialization from collection creation to fix
  migration timing
- UI: hide-pinned filter now checks tagPinned instead of tagPrecision
- 🧪 Tests for rolling alias detection, container model property, mapper, and
  hide-pinned filter

Author: s-b-e-n-s-o-n

app/model/container.test.ts

@@ -508,6 +508,7 @@ test('model should be validated when compliant', async () => {
 
     linkTemplate: 'https://release-${major}.${minor}.${patch}.acme.com',
     link: 'https://release-1.0.0.acme.com',
+    tagPinned: true,
     updateAvailable: true,
     updateKind: {
       kind: 'tag',
@@ -729,6 +730,62 @@ test.each([
   expect(containerValidated.image.tag.tagPrecision).toBe(tagPrecision);
 });
 
+test('model should flag numeric version aliases as tagPinned even when tagPrecision is floating', () => {
+  const containerValidated = container.validate({
+    id: 'container-tag-pinned-floating',
+    name: 'test-tag-pinned-floating',
+    watcher: 'test',
+    image: {
+      id: 'image-tag-pinned-floating',
+      registry: {
+        name: 'hub',
+        url: 'https://hub',
+      },
+      name: 'organization/image',
+      tag: {
+        value: '16-alpine',
+        semver: true,
+        tagPrecision: 'floating',
+      },
+      digest: {
+        watch: false,
+      },
+      architecture: 'arch',
+      os: 'os',
+    },
+  });
+
+  expect(containerValidated.tagPinned).toBe(true);
+});
+
+test('model should not flag rolling aliases as tagPinned', () => {
+  const containerValidated = container.validate({
+    id: 'container-tag-unpinned-latest',
+    name: 'test-tag-unpinned-latest',
+    watcher: 'test',
+    image: {
+      id: 'image-tag-unpinned-latest',
+      registry: {
+        name: 'hub',
+        url: 'https://hub',
+      },
+      name: 'organization/image',
+      tag: {
+        value: 'latest',
+        semver: false,
+        tagPrecision: 'floating',
+      },
+      digest: {
+        watch: false,
+      },
+      architecture: 'arch',
+      os: 'os',
+    },
+  });
+
+  expect(containerValidated.tagPinned).toBe(false);
+});
+
 test('model should reject invalid image.tag.tagPrecision values', () => {
   expect(() =>
     container.validate({
@@ -1525,6 +1582,7 @@ test('flatten should be flatten the nested properties with underscores when call
     status: 'unknown',
     image_architecture: 'arch',
     image_created: '2021-06-12T05:33:38.440Z',
+    image_digest_repo: undefined,
     image_digest_watch: false,
     image_id: 'image-123456789',
     image_name: 'organization/image',
@@ -1541,6 +1599,7 @@ test('flatten should be flatten the nested properties with underscores when call
     display_icon: 'mdi:docker',
     result_link: 'https://release-2.0.0.acme.com',
     result_tag: '2.0.0',
+    tag_pinned: true,
     update_available: true,
     update_kind_kind: 'tag',
     update_kind_local_value: '1.0.0',

app/model/container.ts

@@ -7,6 +7,7 @@ import type {
   ContainerSignatureVerification,
 } from '../security/scan.js';
 import * as tag from '../tag/index.js';
+import { isTagPinned } from '../tag/precision.js';
 import type {
   ContainerUpdateOperationPhase,
   ContainerUpdateOperationStatus,
@@ -152,6 +153,7 @@ export interface Container {
   link?: string;
   triggerInclude?: string;
   triggerExclude?: string;
+  tagPinned?: boolean;
   updatePolicy?: ContainerUpdatePolicy;
   security?: ContainerSecurityState;
   image: ContainerImage;
@@ -248,6 +250,7 @@ const schema = joi.object({
   link: joi.string(),
   triggerInclude: joi.string(),
   triggerExclude: joi.string(),
+  tagPinned: joi.boolean(),
   updatePolicy: joi.object({
     skipTags: joi.array().items(joi.string()),
     skipDigests: joi.array().items(joi.string()),
@@ -626,6 +629,15 @@ function getLink(container: Container, originalTagValue: string) {
   );
 }
 
+function addTagPinnedProperty(container: Container) {
+  Object.defineProperty(container, 'tagPinned', {
+    enumerable: true,
+    get(this: Container) {
+      return isTagPinned(this.image.tag.value, this.transformTags);
+    },
+  });
+}
+
 /**
  * Computed function to check whether there is an update.
  * @param container
@@ -755,6 +767,7 @@ export function validate(container: unknown): Container {
   delete containerValidated.image?.registry?.lookupUrl;
 
   // Add computed properties
+  addTagPinnedProperty(containerValidated);
   addUpdateAvailableProperty(containerValidated);
   addUpdateKindProperty(containerValidated);
   addUpdateAgeProperty(containerValidated);

app/store/app.test.ts

@@ -53,10 +53,11 @@ test('createCollections should call migrate when versions are different', async
     addCollection: () => null,
   };
   app.createCollections(db);
+  app.completeStartupInitialization();
   expect(migrate.migrate).toHaveBeenCalledWith('1.0.0', '2.0.0');
 });
 
-test('createCollections should run startup repair even when versions are different', async () => {
+test('completeStartupInitialization should run startup repair even when versions are different', async () => {
   const db = {
     getCollection: () => ({
       findOne: () => ({
@@ -69,6 +70,7 @@ test('createCollections should run startup repair even when versions are differe
     addCollection: () => null,
   };
   app.createCollections(db);
+  app.completeStartupInitialization();
   expect(migrate.repairDataOnStartup).toHaveBeenCalledTimes(1);
 });
 
@@ -85,10 +87,11 @@ test('createCollections should not call migrate when versions are identical', as
     addCollection: () => null,
   };
   app.createCollections(db);
+  app.completeStartupInitialization();
   expect(migrate.migrate).not.toHaveBeenCalled();
 });
 
-test('createCollections should run startup repair when versions are identical', async () => {
+test('completeStartupInitialization should run startup repair when versions are identical', async () => {
   const db = {
     getCollection: () => ({
       findOne: () => ({
@@ -101,6 +104,7 @@ test('createCollections should run startup repair when versions are identical',
     addCollection: () => null,
   };
   app.createCollections(db);
+  app.completeStartupInitialization();
   expect(migrate.migrate).not.toHaveBeenCalled();
   expect(migrate.repairDataOnStartup).toHaveBeenCalledTimes(1);
 });
@@ -167,6 +171,7 @@ test('isUpgrade should return false when app collection is empty (fresh install)
     }),
   };
   app.createCollections(db);
+  app.completeStartupInitialization();
   expect(app.isUpgrade()).toBe(false);
 });
 
@@ -183,6 +188,7 @@ test('isUpgrade should return true when app collection has a previous version (u
     addCollection: () => null,
   };
   app.createCollections(db);
+  app.completeStartupInitialization();
   expect(app.isUpgrade()).toBe(true);
 });
 

app/store/app.ts

@@ -48,6 +48,9 @@ function saveAppInfosAndMigrate() {
 
 export function createCollections(db: AppStoreDb) {
   app = initCollection(db, 'app') as AppCollection;
+}
+
+export function completeStartupInitialization() {
   saveAppInfosAndMigrate();
 }
 

app/store/index.startup-repair.test.ts

@@ -0,0 +1,83 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createContainerFixture } from '../test/helpers.js';
+
+const ENV_KEYS = ['DD_STORE_PATH', 'DD_STORE_FILE', 'DD_VERSION'] as const;
+
+function setStoreEnv(storePath: string) {
+  process.env.DD_STORE_PATH = storePath;
+  process.env.DD_STORE_FILE = 'dd.json';
+  process.env.DD_VERSION = '1.5.0';
+}
+
+describe('store startup repair integration', () => {
+  test('init should backfill missing tagPrecision for persisted containers after restart', async () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'drydock-store-'));
+    const previousEnv = Object.fromEntries(ENV_KEYS.map((key) => [key, process.env[key]]));
+
+    try {
+      setStoreEnv(tempDir);
+      vi.resetModules();
+
+      const store = await import('./index.js');
+      const storeContainer = await import('./container.js');
+
+      await store.init();
+      storeContainer.insertContainer(
+        createContainerFixture({
+          id: 'startup-repair-specific',
+          image: {
+            id: 'image-startup-repair-specific',
+            registry: {
+              name: 'registry',
+              url: 'https://hub',
+            },
+            name: 'organization/image',
+            tag: {
+              value: '1.2.3',
+              semver: true,
+            },
+            digest: {
+              watch: false,
+              repo: undefined,
+            },
+            architecture: 'arch',
+            os: 'os',
+            created: '2021-06-12T05:33:38.440Z',
+          },
+          result: {
+            tag: '1.2.3',
+          },
+        }),
+      );
+      await store.save();
+
+      setStoreEnv(tempDir);
+      vi.resetModules();
+
+      const restartedStore = await import('./index.js');
+      const restartedContainer = await import('./container.js');
+
+      await restartedStore.init();
+
+      expect(restartedContainer.getContainerRaw('startup-repair-specific')?.image.tag).toEqual(
+        expect.objectContaining({
+          value: '1.2.3',
+          tagPrecision: 'specific',
+        }),
+      );
+    } finally {
+      ENV_KEYS.forEach((key) => {
+        const value = previousEnv[key];
+        if (value === undefined) {
+          delete process.env[key];
+        } else {
+          process.env[key] = value;
+        }
+      });
+      fs.rmSync(tempDir, { recursive: true, force: true });
+      vi.resetModules();
+    }
+  });
+});

app/store/index.test.ts

@@ -40,7 +40,7 @@ const {
   }
 
   function createCollectionsMock() {
-    return { createCollections: vi.fn() };
+    return { createCollections: vi.fn(), completeStartupInitialization: vi.fn() };
   }
 
   function createLogMock() {
@@ -124,6 +124,7 @@ describe('Store Module', () => {
     expect(notification.createCollections).toHaveBeenCalled();
     expect(settings.createCollections).toHaveBeenCalled();
     expect(updateOperation.createCollections).toHaveBeenCalled();
+    expect(app.completeStartupInitialization).toHaveBeenCalled();
   });
 
   test('should create directory if it does not exist', async () => {
@@ -173,6 +174,7 @@ describe('Store Module', () => {
     expect(notification.createCollections).toHaveBeenCalled();
     expect(settings.createCollections).toHaveBeenCalled();
     expect(updateOperation.createCollections).toHaveBeenCalled();
+    expect(app.completeStartupInitialization).toHaveBeenCalled();
   });
 
   test('should save database when persistence is enabled', async () => {

app/store/index.ts

@@ -44,6 +44,7 @@ function createCollections() {
   notification.createCollections(db);
   settings.createCollections(db);
   updateOperation.createCollections(db);
+  app.completeStartupInitialization();
 }
 
 /**

app/tag/precision.test.ts

@@ -1,4 +1,4 @@
-import { classifyTagPrecision, getNumericTagShape } from './precision.js';
+import { classifyTagPrecision, getNumericTagShape, isTagPinned } from './precision.js';
 
 describe('tag/precision', () => {
   describe('getNumericTagShape', () => {
@@ -54,4 +54,16 @@ describe('tag/precision', () => {
       ).toBe('specific');
     });
   });
+
+  describe('isTagPinned', () => {
+    test('treats numeric version aliases as pinned', () => {
+      expect(isTagPinned('16-alpine', undefined)).toBe(true);
+      expect(isTagPinned('1.2.3', undefined)).toBe(true);
+    });
+
+    test('treats rolling channel aliases as not pinned', () => {
+      expect(isTagPinned('latest', undefined)).toBe(false);
+      expect(isTagPinned('stable', undefined)).toBe(false);
+    });
+  });
 });