@awsesh/core 1.0.2 → 1.0.4

package/filesystem.d.ts

@@ -0,0 +1,6 @@
+export declare function readJsonFile<T>(filePath: string): Promise<T>;
+export declare function writeJsonFile(filePath: string, value: unknown): Promise<void>;
+export declare function fileExists(filePath: string): Promise<boolean>;
+export declare function listJsonFiles(dir: string, options?: {
+    recursive?: boolean;
+}): Promise<string[]>;

package/index.js

@@ -20058,52 +20058,89 @@ var Credentials;
   Credentials.listProfiles = listProfiles;
 })(Credentials ||= {});
 // src/sessions.ts
+import path3 from "node:path";
+import fs3 from "node:fs/promises";
+
+// src/filesystem.ts
 import path2 from "node:path";
 import fs2 from "node:fs/promises";
+async function readJsonFile(filePath) {
+  const content = await fs2.readFile(filePath, "utf-8");
+  return JSON.parse(content);
+}
+async function writeJsonFile(filePath, value) {
+  await fs2.writeFile(filePath, JSON.stringify(value, null, 2));
+}
+async function fileExists(filePath) {
+  try {
+    await fs2.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function listJsonFiles(dir, options = {}) {
+  const recursive = options.recursive ?? false;
+  const entries = await fs2.readdir(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const entryPath = path2.join(dir, entry.name);
+    if (entry.isFile() && entry.name.endsWith(".json")) {
+      files.push(entry.name);
+      continue;
+    }
+    if (recursive && entry.isDirectory()) {
+      const nestedFiles = await listJsonFiles(entryPath, { recursive: true });
+      for (const nestedFile of nestedFiles) {
+        files.push(path2.posix.join(entry.name, nestedFile));
+      }
+    }
+  }
+  return files;
+}
+
+// src/sessions.ts
 var Sessions;
 ((Sessions) => {
   function create(options) {
     const { dir } = options;
     async function ensureDir() {
-      await fs2.mkdir(dir, { recursive: true }).catch(() => {});
+      await fs3.mkdir(dir, { recursive: true }).catch(() => {});
     }
     return {
       async list() {
         try {
           await ensureDir();
-          const glob = new Bun.Glob("*.json");
-          const files = await Array.fromAsync(glob.scan({ cwd: dir, onlyFiles: true }));
-          const sessions = await Promise.all(files.map((file) => Bun.file(path2.join(dir, file)).json()));
+          const files = await listJsonFiles(dir);
+          const sessions = await Promise.all(files.map((file) => readJsonFile(path3.join(dir, file))));
           return sessions;
         } catch {
           return [];
         }
       },
       async load(name) {
-        const target = path2.join(dir, `${name}.json`);
-        const file = Bun.file(target);
-        if (!await file.exists())
+        const target = path3.join(dir, `${name}.json`);
+        if (!await fileExists(target))
           return;
-        return file.json();
+        return readJsonFile(target);
       },
       async save(session) {
         await ensureDir();
-        const target = path2.join(dir, `${session.name}.json`);
-        await Bun.write(target, JSON.stringify(session, null, 2));
+        const target = path3.join(dir, `${session.name}.json`);
+        await writeJsonFile(target, session);
       },
       async remove(name) {
-        const target = path2.join(dir, `${name}.json`);
-        await fs2.unlink(target).catch(() => {});
+        const target = path3.join(dir, `${name}.json`);
+        await fs3.unlink(target).catch(() => {});
       },
       async exists(name) {
-        const target = path2.join(dir, `${name}.json`);
-        return Bun.file(target).exists();
+        const target = path3.join(dir, `${name}.json`);
+        return fileExists(target);
       },
       async count() {
         try {
           await ensureDir();
-          const glob = new Bun.Glob("*.json");
-          const files = await Array.fromAsync(glob.scan({ cwd: dir, onlyFiles: true }));
+          const files = await listJsonFiles(dir);
           return files.length;
         } catch {
           return 0;
@@ -20114,50 +20151,46 @@ var Sessions;
   Sessions.create = create;
 })(Sessions ||= {});
 // src/storage.ts
-import path3 from "node:path";
-import fs3 from "node:fs/promises";
+import path4 from "node:path";
+import fs4 from "node:fs/promises";
 var Storage;
 ((Storage) => {
   function create(options) {
     const { dir } = options;
     async function ensureDir(dirPath) {
-      await fs3.mkdir(dirPath, { recursive: true }).catch(() => {});
+      await fs4.mkdir(dirPath, { recursive: true }).catch(() => {});
     }
     return {
       async read(key) {
-        const target = path3.join(dir, `${key}.json`);
+        const target = path4.join(dir, `${key}.json`);
         try {
-          const file = Bun.file(target);
-          if (!await file.exists())
-            return;
-          return file.json();
+          return await readJsonFile(target);
         } catch {
           return;
         }
       },
       async write(key, value) {
-        const target = path3.join(dir, `${key}.json`);
-        await ensureDir(path3.dirname(target));
-        await Bun.write(target, JSON.stringify(value, null, 2));
+        const target = path4.join(dir, `${key}.json`);
+        await ensureDir(path4.dirname(target));
+        await writeJsonFile(target, value);
       },
       async update(key, fn) {
-        const target = path3.join(dir, `${key}.json`);
+        const target = path4.join(dir, `${key}.json`);
         let content;
         try {
-          const file = Bun.file(target);
-          content = await file.json();
+          content = await readJsonFile(target);
         } catch {
           content = {};
         }
         const updated = fn(content);
-        await ensureDir(path3.dirname(target));
-        await Bun.write(target, JSON.stringify(updated, null, 2));
+        await ensureDir(path4.dirname(target));
+        await writeJsonFile(target, updated);
         return updated;
       },
       async remove(key) {
-        const target = path3.join(dir, `${key}.json`);
+        const target = path4.join(dir, `${key}.json`);
         try {
-          await fs3.unlink(target);
+          await fs4.unlink(target);
         } catch (error) {
           const err = error;
           if (err.code !== "ENOENT")
@@ -20165,10 +20198,9 @@ var Storage;
         }
       },
       async list(prefix) {
-        const targetDir = path3.join(dir, prefix);
+        const targetDir = path4.join(dir, prefix);
         try {
-          const glob = new Bun.Glob("**/*.json");
-          const results = await Array.fromAsync(glob.scan({ cwd: targetDir, onlyFiles: true }));
+          const results = await listJsonFiles(targetDir, { recursive: true });
           return results.map((x) => x.slice(0, -5)).sort();
         } catch (error) {
           const err = error;
@@ -20178,9 +20210,9 @@ var Storage;
         }
       },
       async exists(key) {
-        const target = path3.join(dir, `${key}.json`);
+        const target = path4.join(dir, `${key}.json`);
         try {
-          await fs3.access(target);
+          await fs4.access(target);
           return true;
         } catch {
           return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@awsesh/core",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "AWS SSO session management SDK",
   "type": "module",
   "main": "./index.js",