@tehw0lf/yaft 0.0.4 → 0.0.6

package/.github/workflows/build.yml

@@ -14,6 +14,7 @@ jobs:
       actions: write
       contents: write
       packages: write
+      id-token: write
     with:
       tool: "npm"
       test: "run test"
@@ -22,5 +23,3 @@ jobs:
       event_name: ${{ github.event_name }}
       artifact_path: "dist"
       library_path: "dist"
-    secrets:
-      NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

package/jest.config.js

@@ -7,6 +7,9 @@ module.exports = {
   globals: {},
   coverageDirectory: 'coverage/yaft',
   testEnvironment: "node",
+  testMatch: [
+    '<rootDir>/src/**/*.spec.ts'
+  ],
   transform: {
     "^.+\.tsx?$": ["ts-jest",{}],
   },

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@tehw0lf/yaft",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "YaFT - Feature Toggles using Go&PostgreSQL or any source!",
   "type": "commonjs",
   "scripts": {
     "build": "tsc && npm pkg delete devDependencies && cp package.json README.md logo.svg dist/",
-    "test": "jest"
+    "test": "npx jest"
   },
   "repository": {
     "type": "git",

package/src/FeatureToggle.ts

@@ -9,6 +9,7 @@ export type Feature = {
   value: string;
   activeAt: string;
   disabledAt: string;
+  tags?: string[];
 };
 
 export interface FeatureProvider<T> {

package/src/examples/ApiServiceBooleanProvider.ts

@@ -17,7 +17,7 @@ export class ApiServiceBooleanProvider implements FeatureProvider<boolean> {
   async getCollectionHash(configPathOrUrl: string): Promise<void> {
     try {
       const response = await axios.get(configPathOrUrl);
-      const newHash = response.data.value;
+      const newHash = response.data.collectionHash || response.data.value;
       if (this.collectionHash !== newHash) {
         this.collectionHash = newHash;
         await this.getConfig(`${this.apiUrl}/features/${this.baseUUID}`);
@@ -30,7 +30,23 @@ export class ApiServiceBooleanProvider implements FeatureProvider<boolean> {
   async getConfig(configPathOrUrl: string): Promise<void> {
     try {
       const response = await axios.get(configPathOrUrl);
-      this.data = response.data.value;
+      // Handle Go backend response format
+      const featuresArray = response.data.toggles || response.data.value || [];
+      
+      // Convert array to keyed boolean object and handle capitalized field names
+      this.data = {};
+      if (Array.isArray(featuresArray)) {
+        featuresArray.forEach((feature: any) => {
+          const key = feature.key || feature.Key;
+          const value = feature.value || feature.Value;
+          if (key) {
+            this.data[key] = value === 'true' || value === true;
+          }
+        });
+      } else {
+        // Fallback for object format
+        this.data = featuresArray;
+      }
     } catch (error) {
       console.error("Failed to fetch feature toggle from API:", error);
     }

package/src/examples/ApiServiceFeatureProvider.ts

@@ -17,7 +17,7 @@ export class ApiServiceFeatureProvider implements FeatureProvider<Feature> {
   async getCollectionHash(configPathOrUrl: string): Promise<void> {
     try {
       const response = await axios.get(configPathOrUrl);
-      const newHash = response.data.value;
+      const newHash = response.data.collectionHash || response.data.value;
       if (this.collectionHash !== newHash) {
         this.collectionHash = newHash;
         await this.getConfig(`${this.apiUrl}/features/${this.baseUUID}`);
@@ -30,7 +30,28 @@ export class ApiServiceFeatureProvider implements FeatureProvider<Feature> {
   async getConfig(configPathOrUrl: string): Promise<void> {
     try {
       const response = await axios.get(configPathOrUrl);
-      this.data = response.data.value;
+      // Handle Go backend response format
+      const featuresArray = response.data.toggles || response.data.value || [];
+      
+      // Convert array to keyed object and handle capitalized field names
+      this.data = {};
+      if (Array.isArray(featuresArray)) {
+        featuresArray.forEach((feature: any) => {
+          const normalizedFeature = {
+            key: feature.key || feature.Key,
+            value: feature.value || feature.Value,
+            activeAt: feature.activeAt || feature.ActiveAt,
+            disabledAt: feature.disabledAt || feature.DisabledAt,
+            tags: feature.tags || feature.Tags || [],
+          };
+          if (normalizedFeature.key) {
+            this.data[normalizedFeature.key] = normalizedFeature;
+          }
+        });
+      } else {
+        // Fallback for object format
+        this.data = featuresArray;
+      }
     } catch (error) {
       console.error("Failed to fetch feature toggle from API:", error);
     }
@@ -41,9 +62,26 @@ export class ApiServiceFeatureProvider implements FeatureProvider<Feature> {
 
     if (feature === undefined || feature === null) return false;
 
-    if (Date.now() >= Date.parse(feature.disabledAt)) return false;
-    if (Date.now() >= Date.parse(feature.activeAt)) return true;
+    // First check: value must be "true"
+    if (feature.value !== "true") return false;
+
+    // Second check: if activeAt is set and in future, not yet active
+    if (feature.activeAt && feature.activeAt !== "") {
+      const activeTime = Date.parse(feature.activeAt);
+      if (!isNaN(activeTime) && Date.now() < activeTime) {
+        return false;
+      }
+    }
+
+    // Third check: if disabledAt is set and in past, already disabled
+    if (feature.disabledAt && feature.disabledAt !== "") {
+      const disabledTime = Date.parse(feature.disabledAt);
+      if (!isNaN(disabledTime) && Date.now() >= disabledTime) {
+        return false;
+      }
+    }
 
-    return JSON.parse(feature.value);
+    // All checks passed, feature is enabled
+    return true;
   }
 }

package/src/examples/LocalStorageFeatureProvider.ts

@@ -22,9 +22,26 @@ export class LocalStorageFeatureProvider implements FeatureProvider<Feature> {
 
     if (feature === undefined || feature === null) return false;
 
-    if (Date.now() >= Date.parse(feature.disabledAt)) return false;
-    if (Date.now() >= Date.parse(feature.activeAt)) return true;
+    // First check: value must be "true"
+    if (feature.value !== "true") return false;
 
-    return JSON.parse(feature.value);
+    // Second check: if activeAt is set and in future, not yet active
+    if (feature.activeAt && feature.activeAt !== "") {
+      const activeTime = Date.parse(feature.activeAt);
+      if (!isNaN(activeTime) && Date.now() < activeTime) {
+        return false;
+      }
+    }
+
+    // Third check: if disabledAt is set and in past, already disabled
+    if (feature.disabledAt && feature.disabledAt !== "") {
+      const disabledTime = Date.parse(feature.disabledAt);
+      if (!isNaN(disabledTime) && Date.now() >= disabledTime) {
+        return false;
+      }
+    }
+
+    // All checks passed, feature is enabled
+    return true;
   }
 }

package/src/test/error-handling.spec.ts

@@ -6,6 +6,7 @@ import axios from 'axios';
 // Mock axios for API provider tests
 jest.mock('axios');
 const mockedAxios = axios as jest.Mocked<typeof axios>;
+mockedAxios.get = jest.fn();
 
 describe('Error Handling and Edge Cases', () => {
   let mockProvider: FeatureProvider<boolean>;
@@ -18,6 +19,8 @@ describe('Error Handling and Edge Cases', () => {
     };
     FeatureToggleBase.featureProvider = mockProvider;
     jest.clearAllMocks();
+    // Reset axios mock
+    (mockedAxios.get as jest.Mock).mockReset();
   });
 
   describe('Provider Initialization Errors', () => {
@@ -136,9 +139,8 @@ describe('Error Handling and Edge Cases', () => {
         }
       })();
 
-      expect(() => {
-        provider.isEnabled('invalidBoolean');
-      }).toThrow(); // JSON.parse should throw for invalid boolean strings
+      // New behavior: safely returns false for any value that is not "true"
+      expect(provider.isEnabled('invalidBoolean')).toBe(false);
     });
   });
 

package/src/test/time-based-logic.spec.ts

@@ -0,0 +1,169 @@
+import { Feature } from '../FeatureToggle';
+import { LocalStorageFeatureProvider } from '../examples/LocalStorageFeatureProvider';
+
+describe('Time-based Feature Evaluation Logic', () => {
+  describe('Current Time Logic', () => {
+    it('should handle feature with value=true and no dates (always enabled)', () => {
+      const provider = new (class extends LocalStorageFeatureProvider {
+        constructor() {
+          super('');
+          this.data = {
+            'always-enabled': {
+              key: 'always-enabled',
+              value: 'true',
+              activeAt: '',
+              disabledAt: ''
+            }
+          };
+        }
+      })();
+
+      expect(provider.isEnabled('always-enabled')).toBe(true);
+    });
+
+    it('should handle feature with value=false (always disabled)', () => {
+      const provider = new (class extends LocalStorageFeatureProvider {
+        constructor() {
+          super('');
+          this.data = {
+            'always-disabled': {
+              key: 'always-disabled',
+              value: 'false',
+              activeAt: '',
+              disabledAt: ''
+            }
+          };
+        }
+      })();
+
+      expect(provider.isEnabled('always-disabled')).toBe(false);
+    });
+
+    it('should disable feature if disabledAt is in the past', () => {
+      const pastDate = new Date(Date.now() - 86400000).toISOString(); // 1 day ago
+
+      const provider = new (class extends LocalStorageFeatureProvider {
+        constructor() {
+          super('');
+          this.data = {
+            'past-disabled': {
+              key: 'past-disabled',
+              value: 'true',
+              activeAt: '',
+              disabledAt: pastDate
+            }
+          };
+        }
+      })();
+
+      expect(provider.isEnabled('past-disabled')).toBe(false);
+    });
+
+    it('should enable feature if activeAt is in the past and no disabledAt', () => {
+      const pastDate = new Date(Date.now() - 86400000).toISOString(); // 1 day ago
+
+      const provider = new (class extends LocalStorageFeatureProvider {
+        constructor() {
+          super('');
+          this.data = {
+            'past-active': {
+              key: 'past-active',
+              value: 'true',
+              activeAt: pastDate,
+              disabledAt: ''
+            }
+          };
+        }
+      })();
+
+      expect(provider.isEnabled('past-active')).toBe(true);
+    });
+
+    it('BUG: should NOT enable feature if activeAt is in the future', () => {
+      const futureDate = new Date(Date.now() + 86400000).toISOString(); // 1 day from now
+
+      const provider = new (class extends LocalStorageFeatureProvider {
+        constructor() {
+          super('');
+          this.data = {
+            'future-active': {
+              key: 'future-active',
+              value: 'true',
+              activeAt: futureDate,
+              disabledAt: ''
+            }
+          };
+        }
+      })();
+
+      // CURRENT BUGGY BEHAVIOR: Returns true because it falls through to line 28
+      // Date.now() >= Date.parse(futureDate) is false, so it skips line 26
+      // Falls through to: return JSON.parse(feature.value); which returns true
+
+      // EXPECTED BEHAVIOR: Should return false because feature is not yet active
+      expect(provider.isEnabled('future-active')).toBe(false);
+    });
+
+    it('should enable feature if within activeAt and disabledAt window', () => {
+      const pastDate = new Date(Date.now() - 86400000).toISOString(); // 1 day ago
+      const futureDate = new Date(Date.now() + 86400000).toISOString(); // 1 day from now
+
+      const provider = new (class extends LocalStorageFeatureProvider {
+        constructor() {
+          super('');
+          this.data = {
+            'windowed-feature': {
+              key: 'windowed-feature',
+              value: 'true',
+              activeAt: pastDate,
+              disabledAt: futureDate
+            }
+          };
+        }
+      })();
+
+      expect(provider.isEnabled('windowed-feature')).toBe(true);
+    });
+
+    it('should handle NaN dates gracefully (empty strings)', () => {
+      const provider = new (class extends LocalStorageFeatureProvider {
+        constructor() {
+          super('');
+          this.data = {
+            'empty-dates': {
+              key: 'empty-dates',
+              value: 'true',
+              activeAt: '',
+              disabledAt: ''
+            }
+          };
+        }
+      })();
+
+      // Date.parse('') returns NaN
+      // Date.now() >= NaN is false for both checks
+      // Should fall through to: return JSON.parse(feature.value);
+      expect(provider.isEnabled('empty-dates')).toBe(true);
+    });
+
+    it('should handle invalid date strings gracefully', () => {
+      const provider = new (class extends LocalStorageFeatureProvider {
+        constructor() {
+          super('');
+          this.data = {
+            'invalid-dates': {
+              key: 'invalid-dates',
+              value: 'true',
+              activeAt: 'not-a-date',
+              disabledAt: 'also-not-a-date'
+            }
+          };
+        }
+      })();
+
+      // Date.parse('not-a-date') returns NaN
+      // Similar behavior to empty strings
+      expect(provider.isEnabled('invalid-dates')).toBe(true);
+    });
+  });
+});

package/tsconfig.json

@@ -6,5 +6,6 @@
     "declaration": true,
     "outDir": "./dist"
   },
-  "include": ["**/**/*.ts"]
+  "include": ["src/**/*.ts"],
+  "exclude": ["**/*.spec.ts", "**/*.test.ts", "**/test/**/*"]
 }