opticedge-cloud-utils 1.1.12 → 1.1.14

package/dist/chunk.d.ts

@@ -0,0 +1 @@
+export declare function chunkByBytes(arr: any[], maxBytes?: number): any[][];

package/dist/chunk.js

@@ -0,0 +1,37 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chunkByBytes = chunkByBytes;
+function chunkByBytes(arr, maxBytes = 700000) {
+    // 700KB safe default
+    const chunks = [];
+    let current = [];
+    let curBytes = 0;
+    for (const item of arr) {
+        const s = JSON.stringify(item);
+        const b = Buffer.byteLength(s, 'utf8');
+        // if a single item exceeds maxBytes, push it alone (or skip)
+        if (b > maxBytes) {
+            // optionally log and skip - here we'll push as its own chunk
+            if (current.length) {
+                chunks.push(current);
+                current = [];
+                curBytes = 0;
+            }
+            chunks.push([item]);
+            continue;
+        }
+        if (curBytes + b > maxBytes) {
+            chunks.push(current);
+            current = [item];
+            curBytes = b;
+        }
+        else {
+            current.push(item);
+            curBytes += b;
+        }
+    }
+    if (current.length)
+        chunks.push(current);
+    return chunks;
+}

package/dist/db/mongo.d.ts

@@ -1,4 +1,5 @@
-import { Collection, Document } from 'mongodb';
+import { Db, Collection, Document } from 'mongodb';
 export declare function connectToMongo(projectId: string, uriSecret: string, dbName: string): Promise<void>;
 export declare function connectToMongoWithUri(uri: string, dbName: string): Promise<void>;
+export declare function getDb(): Db;
 export declare function getCollection<T extends Document = Document>(name: string): Collection<T>;

package/dist/db/mongo.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.connectToMongo = connectToMongo;
 exports.connectToMongoWithUri = connectToMongoWithUri;
+exports.getDb = getDb;
 exports.getCollection = getCollection;
 const mongodb_1 = require("mongodb");
 const secrets_1 = require("../secrets");
@@ -33,6 +34,11 @@ async function connectToMongoWithUri(uri, dbName) {
     }
     await connectPromise;
 }
+function getDb() {
+    if (!db)
+        throw new Error('Mongo not initialized. Call connectToMongo(...) first.');
+    return db;
+}
 function getCollection(name) {
     if (!db)
         throw new Error('Mongo not initialized');

package/dist/env.js

@@ -1,4 +1,5 @@
 "use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getEnv = getEnv;
 function getEnv(name, fallback) {

package/dist/index.d.ts

@@ -4,6 +4,7 @@ export * from './db/mongo3';
 export * from './tw/utils';
 export * from './tw/wallet';
 export * from './auth';
+export * from './chunk';
 export * from './env';
 export * from './parser';
 export * from './regex';

package/dist/index.js

@@ -20,6 +20,7 @@ __exportStar(require("./db/mongo3"), exports);
 __exportStar(require("./tw/utils"), exports);
 __exportStar(require("./tw/wallet"), exports);
 __exportStar(require("./auth"), exports);
+__exportStar(require("./chunk"), exports);
 __exportStar(require("./env"), exports);
 __exportStar(require("./parser"), exports);
 __exportStar(require("./regex"), exports);

package/package.json

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

package/src/chunk.ts

@@ -0,0 +1,33 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+export function chunkByBytes(arr: any[], maxBytes = 700_000) {
+  // 700KB safe default
+  const chunks: any[][] = []
+  let current: any[] = []
+  let curBytes = 0
+  for (const item of arr) {
+    const s = JSON.stringify(item)
+    const b = Buffer.byteLength(s, 'utf8')
+    // if a single item exceeds maxBytes, push it alone (or skip)
+    if (b > maxBytes) {
+      // optionally log and skip - here we'll push as its own chunk
+      if (current.length) {
+        chunks.push(current)
+        current = []
+        curBytes = 0
+      }
+      chunks.push([item])
+      continue
+    }
+    if (curBytes + b > maxBytes) {
+      chunks.push(current)
+      current = [item]
+      curBytes = b
+    } else {
+      current.push(item)
+      curBytes += b
+    }
+  }
+  if (current.length) chunks.push(current)
+  return chunks
+}

package/src/db/mongo.ts

@@ -34,6 +34,11 @@ export async function connectToMongoWithUri(uri: string, dbName: string) {
   await connectPromise
 }
 
+export function getDb(): Db {
+  if (!db) throw new Error('Mongo not initialized. Call connectToMongo(...) first.')
+  return db
+}
+
 export function getCollection<T extends Document = Document>(name: string): Collection<T> {
   if (!db) throw new Error('Mongo not initialized')
   return db.collection<T>(name)

package/src/env.ts

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
 export function getEnv(name: string, fallback?: any): any {
   const value = process.env[name]
   if (!value) {

package/src/index.ts

@@ -4,6 +4,7 @@ export * from './db/mongo3'
 export * from './tw/utils'
 export * from './tw/wallet'
 export * from './auth'
+export * from './chunk'
 export * from './env'
 export * from './parser'
 export * from './regex'

package/tests/chunk.test.ts

@@ -0,0 +1,48 @@
+import { chunkByBytes } from '../src/chunk'
+
+describe('chunkByBytes', () => {
+  test('splits array into chunks based on byte size', () => {
+    const arr = [
+      { id: 'a', val: 'x'.repeat(100) },
+      { id: 'b', val: 'y'.repeat(100) },
+      { id: 'c', val: 'z'.repeat(100) }
+    ]
+    const chunks = chunkByBytes(arr, 200) // 200 bytes max per chunk
+    expect(chunks.length).toBeGreaterThan(1) // should split
+    expect(chunks.flat()).toEqual(arr) // all items present
+  })
+
+  test('puts single large item in its own chunk', () => {
+    const arr = [{ id: 'big', val: 'x'.repeat(1000) }]
+    const chunks = chunkByBytes(arr, 100)
+    expect(chunks).toEqual([arr]) // large item pushed alone
+  })
+
+  test('does not split if all items fit within maxBytes', () => {
+    const arr = [
+      { id: 'a', val: 'x' },
+      { id: 'b', val: 'y' }
+    ]
+    const chunks = chunkByBytes(arr, 1000)
+    expect(chunks).toEqual([arr])
+  })
+
+  test('uses default maxBytes if not provided', () => {
+    const arr = [{ id: 'a', val: 'x'.repeat(10) }]
+    // call without maxBytes
+    const chunks = chunkByBytes(arr)
+    expect(chunks.flat()).toEqual(arr) // all items present
+  })
+
+  test('flushes current chunk when a single item exceeds maxBytes', () => {
+    const arr = [
+      { id: '1', val: 'x'.repeat(50) }, // first small item
+      { id: '2', val: 'y'.repeat(200) } // oversized item
+    ]
+    // set maxBytes small enough to trigger oversized item
+    const chunks = chunkByBytes(arr, 100)
+    expect(chunks.length).toBe(2) // first small chunk + oversized item alone
+    expect(chunks[0]).toEqual([arr[0]]) // first item in first chunk
+    expect(chunks[1]).toEqual([arr[1]]) // second item alone
+  })
+})

package/tests/db/mongo.test.ts

@@ -1,4 +1,4 @@
-import { connectToMongo, connectToMongoWithUri, getCollection } from '../../src/db/mongo'
+import { connectToMongo, connectToMongoWithUri, getCollection, getDb } from '../../src/db/mongo'
 import { MongoClient, Db } from 'mongodb'
 import * as secretsModule from '../../src/secrets'
 
@@ -37,18 +37,27 @@ describe('Mongo Utils', () => {
     expect(mockDb.collection).toHaveBeenCalledWith('users')
   })
 
-  it('should throw error if db is not initialized', () => {
+  it('getDb should return the initialized Db instance', async () => {
+    await connectToMongo('test-project', 'mongo-uri-secret', 'test-db')
+    const got = getDb()
+    expect(got).toBe(mockDb)
+  })
+
+  it('should throw error if db is not initialized (getCollection/getDb)', () => {
     jest.isolateModules(() => {
+      // require a fresh copy of the module so module-level state is uninitialized
       // eslint-disable-next-line @typescript-eslint/no-require-imports
-      const { getCollection } = require('../../src/db/mongo')
-      expect(() => getCollection('users')).toThrow('Mongo not initialized')
+      const mod = require('../../src/db/mongo')
+      expect(() => mod.getCollection('users')).toThrow(/Mongo not initialized/)
+      expect(() => mod.getDb()).toThrow(/Mongo not initialized/)
     })
   })
 })
 
 describe('Mongo Utils 2', () => {
-  it('should connect to MongoDB and store client/db', async () => {
-    jest.isolateModules(async () => {
+  it('should connect to MongoDB and store client/db with URI helper', async () => {
+    // isolate modules so connect state is fresh for this test
+    await jest.isolateModulesAsync(async () => {
       // eslint-disable-next-line @typescript-eslint/no-require-imports
       const { connectToMongoWithUri } = require('../../src/db/mongo')
       await connectToMongoWithUri('mongo-uri', 'test-db')
@@ -58,10 +67,16 @@ describe('Mongo Utils 2', () => {
     })
   })
 
-  it('should return a collection when db is initialized', async () => {
+  it('should return a collection when db is initialized (connectToMongoWithUri)', async () => {
     await connectToMongoWithUri('mongo-uri', 'test-db')
     getCollection('users')
 
     expect(mockDb.collection).toHaveBeenCalledWith('users')
   })
+
+  it('getDb should return the initialized Db instance after connectToMongoWithUri', async () => {
+    await connectToMongoWithUri('mongo-uri', 'test-db')
+    const got = getDb()
+    expect(got).toBe(mockDb)
+  })
 })