opticedge-cloud-utils 1.1.23 → 1.1.25

package/dist/env.d.ts

@@ -1 +1 @@
-export declare function getEnv(name: string, fallback?: any): any;
+export declare function requireEnv(name: string, defaultValue?: string): string;

package/dist/env.js

@@ -1,13 +1,13 @@
 "use strict";
-/* eslint-disable @typescript-eslint/no-explicit-any */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEnv = getEnv;
-function getEnv(name, fallback) {
+exports.requireEnv = requireEnv;
+function requireEnv(name, defaultValue) {
     const value = process.env[name];
-    if (!value) {
-        if (fallback !== undefined)
-            return fallback;
-        throw new Error(`Missing env var ${name}`);
+    if (value === undefined || value === '') {
+        if (defaultValue !== undefined) {
+            return defaultValue;
+        }
+        throw new Error(`${name} env var must be set`);
     }
     return value;
 }

package/dist/parser.d.ts

@@ -1,2 +1,3 @@
 declare const toNumber: (v: any) => number | null;
-export { toNumber };
+declare const parsePositiveInt: (value: string, name: string) => number;
+export { toNumber, parsePositiveInt };

package/dist/parser.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toNumber = void 0;
+exports.parsePositiveInt = exports.toNumber = void 0;
 // Helper: accept number or numeric-string, return number or null
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const toNumber = (v) => {
@@ -11,3 +11,14 @@ const toNumber = (v) => {
     return null;
 };
 exports.toNumber = toNumber;
+const parsePositiveInt = (value, name) => {
+    if (!/^\d+$/.test(value)) {
+        throw new Error(`${name} must be a positive integer`);
+    }
+    const n = Number.parseInt(value, 10);
+    if (!Number.isFinite(n) || n <= 0) {
+        throw new Error(`${name} must be a positive integer`);
+    }
+    return n;
+};
+exports.parsePositiveInt = parsePositiveInt;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opticedge-cloud-utils",
-  "version": "1.1.23",
+  "version": "1.1.25",
   "description": "Common utilities for cloud functions",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/env.ts

@@ -1,10 +1,12 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-export function getEnv(name: string, fallback?: any): any {
+export function requireEnv(name: string, defaultValue?: string): string {
   const value = process.env[name]
-  if (!value) {
-    if (fallback !== undefined) return fallback
-    throw new Error(`Missing env var ${name}`)
+
+  if (value === undefined || value === '') {
+    if (defaultValue !== undefined) {
+      return defaultValue
+    }
+    throw new Error(`${name} env var must be set`)
   }
+
   return value
 }

package/src/parser.ts

@@ -6,4 +6,16 @@ const toNumber = (v: any): number | null => {
   return null
 }
 
-export { toNumber }
+const parsePositiveInt = (value: string, name: string): number => {
+  if (!/^\d+$/.test(value)) {
+    throw new Error(`${name} must be a positive integer`)
+  }
+
+  const n = Number.parseInt(value, 10)
+  if (!Number.isFinite(n) || n <= 0) {
+    throw new Error(`${name} must be a positive integer`)
+  }
+  return n
+}
+
+export { toNumber, parsePositiveInt }

package/tests/env.test.ts

@@ -1,18 +1,61 @@
-import { getEnv } from '../src/env'
+import { requireEnv } from '../src/env'
 
-describe('getEnv', () => {
-  it('returns the value of an existing env var', () => {
-    process.env.TEST_KEY = 'test-value'
-    expect(getEnv('TEST_KEY')).toBe('test-value')
+describe('requireEnv', () => {
+  const ORIGINAL_ENV = process.env
+
+  beforeEach(() => {
+    jest.resetModules()
+    process.env = { ...ORIGINAL_ENV }
+  })
+
+  afterAll(() => {
+    process.env = ORIGINAL_ENV
+  })
+
+  // ============================================================
+  // Success cases
+  // ============================================================
+
+  it('returns env value when set', () => {
+    process.env.TEST_VAR = 'hello'
+    expect(requireEnv('TEST_VAR')).toBe('hello')
+  })
+
+  it('returns "0" correctly (should not treat as missing)', () => {
+    process.env.TEST_VAR = '0'
+    expect(requireEnv('TEST_VAR')).toBe('0')
   })
 
-  it('returns fallback if env var is not set', () => {
-    delete process.env.OPTIONAL_KEY
-    expect(getEnv('OPTIONAL_KEY', 'default')).toBe('default')
+  it('returns "false" correctly (should not treat as missing)', () => {
+    process.env.TEST_VAR = 'false'
+    expect(requireEnv('TEST_VAR')).toBe('false')
+  })
+
+  // ============================================================
+  // Default handling
+  // ============================================================
+
+  it('returns default when env is undefined', () => {
+    delete process.env.TEST_VAR
+    expect(requireEnv('TEST_VAR', 'fallback')).toBe('fallback')
+  })
+
+  it('returns default when env is empty string', () => {
+    process.env.TEST_VAR = ''
+    expect(requireEnv('TEST_VAR', 'fallback')).toBe('fallback')
+  })
+
+  // ============================================================
+  // Error cases
+  // ============================================================
+
+  it('throws when env is undefined and no default provided', () => {
+    delete process.env.TEST_VAR
+    expect(() => requireEnv('TEST_VAR')).toThrow('TEST_VAR env var must be set')
   })
 
-  it('throws error if env var is not set and no fallback provided', () => {
-    delete process.env.MISSING_KEY
-    expect(() => getEnv('MISSING_KEY')).toThrow('Missing env var MISSING_KEY')
+  it('throws when env is empty string and no default provided', () => {
+    process.env.TEST_VAR = ''
+    expect(() => requireEnv('TEST_VAR')).toThrow('TEST_VAR env var must be set')
   })
 })

package/tests/parser.test.ts

@@ -1,19 +1,24 @@
-import { toNumber } from '../src'
+import { toNumber, parsePositiveInt } from '../src'
 
 describe('toNumber', () => {
   it('returns the same number when input is a finite number', () => {
     expect(toNumber(123)).toBe(123)
     expect(toNumber(0)).toBe(0)
+    expect(toNumber(-10)).toBe(-10)
   })
 
   it('returns number when input is a numeric string', () => {
     expect(toNumber('456')).toBe(456)
+    expect(toNumber('0')).toBe(0)
   })
 
   it('returns null for non-numeric strings', () => {
     expect(toNumber('abc')).toBeNull()
     expect(toNumber('123abc')).toBeNull()
     expect(toNumber('')).toBeNull()
+    expect(toNumber(' ')).toBeNull()
+    expect(toNumber('12.3')).toBeNull() // decimal not allowed by regex
+    expect(toNumber('-123')).toBeNull() // negative string not allowed
   })
 
   it('returns null for non-numbers', () => {
@@ -22,5 +27,36 @@ describe('toNumber', () => {
     expect(toNumber(undefined)).toBeNull()
     expect(toNumber(null)).toBeNull()
     expect(toNumber({})).toBeNull()
+    expect(toNumber([])).toBeNull()
+  })
+})
+
+describe('parsePositiveInt', () => {
+  it('parses valid positive integers', () => {
+    expect(parsePositiveInt('1', 'TEST')).toBe(1)
+    expect(parsePositiveInt('10', 'TEST')).toBe(10)
+    expect(parsePositiveInt('001', 'TEST')).toBe(1)
+  })
+
+  it('throws for zero', () => {
+    expect(() => parsePositiveInt('0', 'TEST')).toThrow('TEST must be a positive integer')
+  })
+
+  it('throws for negative numbers', () => {
+    expect(() => parsePositiveInt('-1', 'TEST')).toThrow('TEST must be a positive integer')
+  })
+
+  it('throws for non-numeric values', () => {
+    expect(() => parsePositiveInt('abc', 'TEST')).toThrow('TEST must be a positive integer')
+    expect(() => parsePositiveInt('', 'TEST')).toThrow('TEST must be a positive integer')
+  })
+
+  it('throws for decimals', () => {
+    expect(() => parsePositiveInt('1.5', 'TEST')).toThrow('TEST must be a positive integer')
+  })
+
+  it('throws for NaN-like values', () => {
+    expect(() => parsePositiveInt('NaN', 'TEST')).toThrow('TEST must be a positive integer')
+    expect(() => parsePositiveInt('Infinity', 'TEST')).toThrow('TEST must be a positive integer')
   })
 })