@ts-cloud/core 0.2.6 → 0.2.8

package/dist/index.js

@@ -24246,37 +24246,37 @@ function suggestQuotaIncrease(quotas) {
 }
 // src/utils/cache.ts
 import { createHash as createHash2 } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
+import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync3, readdirSync as readdirSync3, unlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join4 } from "node:path";
 class FileCache {
   cacheDir;
   ttl;
   constructor(cacheDir, options = {}) {
     this.cacheDir = cacheDir;
     this.ttl = options.ttl || 24 * 60 * 60 * 1000;
-    if (!fs.existsSync(cacheDir)) {
-      fs.mkdirSync(cacheDir, { recursive: true });
+    if (!existsSync4(cacheDir)) {
+      mkdirSync(cacheDir, { recursive: true });
     }
   }
   getCachePath(key) {
     const hash2 = createHash2("sha256").update(key).digest("hex");
-    return path.join(this.cacheDir, `${hash2}.json`);
+    return join4(this.cacheDir, `${hash2}.json`);
   }
   get(key) {
     const cachePath = this.getCachePath(key);
-    if (!fs.existsSync(cachePath)) {
+    if (!existsSync4(cachePath)) {
       return;
     }
     try {
-      const data = fs.readFileSync(cachePath, "utf-8");
+      const data = readFileSync3(cachePath, "utf-8");
       const entry = JSON.parse(data);
       if (Date.now() - entry.timestamp > this.ttl) {
-        fs.unlinkSync(cachePath);
+        unlinkSync(cachePath);
         return;
       }
       return entry.value;
     } catch {
-      fs.unlinkSync(cachePath);
+      unlinkSync(cachePath);
       return;
     }
   }
@@ -24287,30 +24287,30 @@ class FileCache {
       timestamp: Date.now(),
       hash: hash2
     };
-    fs.writeFileSync(cachePath, JSON.stringify(entry), "utf-8");
+    writeFileSync2(cachePath, JSON.stringify(entry), "utf-8");
   }
   has(key) {
     return this.get(key) !== undefined;
   }
   clear() {
-    const files = fs.readdirSync(this.cacheDir);
+    const files = readdirSync3(this.cacheDir);
     for (const file of files) {
-      fs.unlinkSync(path.join(this.cacheDir, file));
+      unlinkSync(join4(this.cacheDir, file));
     }
   }
   prune() {
-    const files = fs.readdirSync(this.cacheDir);
+    const files = readdirSync3(this.cacheDir);
     const now = Date.now();
     for (const file of files) {
-      const filePath = path.join(this.cacheDir, file);
+      const filePath = join4(this.cacheDir, file);
       try {
-        const data = fs.readFileSync(filePath, "utf-8");
+        const data = readFileSync3(filePath, "utf-8");
         const entry = JSON.parse(data);
         if (now - entry.timestamp > this.ttl) {
-          fs.unlinkSync(filePath);
+          unlinkSync(filePath);
         }
       } catch {
-        fs.unlinkSync(filePath);
+        unlinkSync(filePath);
       }
     }
   }
@@ -24352,14 +24352,14 @@ class TemplateCache {
 var templateCache = new TemplateCache;
 // src/utils/hash.ts
 import { createHash as createHash3 } from "node:crypto";
-import fs2 from "node:fs";
-import path2 from "node:path";
+import { createReadStream, readdirSync as readdirSync4, statSync as statSync2 } from "node:fs";
+import { join as join5, relative } from "node:path";
 async function hashFile(filePath, options = {}) {
   const algorithm = options.algorithm || "sha256";
   const chunkSize = options.chunkSize || 64 * 1024;
   return new Promise((resolve, reject) => {
     const hash2 = createHash3(algorithm);
-    const stream = fs2.createReadStream(filePath, { highWaterMark: chunkSize });
+    const stream = createReadStream(filePath, { highWaterMark: chunkSize });
     stream.on("data", (chunk) => hash2.update(chunk));
     stream.on("end", () => resolve(hash2.digest("hex")));
     stream.on("error", reject);
@@ -24381,17 +24381,17 @@ async function hashDirectory(dirPath, options = {}) {
   ];
   const files = [];
   async function walk(dir) {
-    const entries = fs2.readdirSync(dir, { withFileTypes: true });
+    const entries = readdirSync4(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path2.join(dir, entry.name);
-      const relativePath = path2.relative(dirPath, fullPath);
+      const fullPath = join5(dir, entry.name);
+      const relativePath = relative(dirPath, fullPath);
       if (ignorePatterns.some((pattern) => relativePath.includes(pattern))) {
         continue;
       }
       if (entry.isDirectory()) {
         await walk(fullPath);
       } else if (entry.isFile()) {
-        const stats = fs2.statSync(fullPath);
+        const stats = statSync2(fullPath);
         const hash2 = await hashFile(fullPath, options);
         files.push({
           path: relativePath,
@@ -24412,7 +24412,7 @@ function hashManifest(fileHashes) {
   return hashString(content);
 }
 function quickHash(filePath) {
-  const stats = fs2.statSync(filePath);
+  const stats = statSync2(filePath);
   return hashString(`${filePath}:${stats.size}:${stats.mtimeMs}`);
 }
 function findChangedFiles(oldHashes, newHashes) {
@@ -24421,16 +24421,16 @@ function findChangedFiles(oldHashes, newHashes) {
   const added = [];
   const modified = [];
   const deleted = [];
-  for (const [path3, newFile] of newMap) {
-    const oldFile = oldMap.get(path3);
+  for (const [path, newFile] of newMap) {
+    const oldFile = oldMap.get(path);
     if (!oldFile) {
       added.push(newFile);
     } else if (oldFile.hash !== newFile.hash) {
       modified.push(newFile);
     }
   }
-  for (const [path3, oldFile] of oldMap) {
-    if (!newMap.has(path3)) {
+  for (const [path, oldFile] of oldMap) {
+    if (!newMap.has(path)) {
       deleted.push(oldFile);
     }
   }
@@ -24443,7 +24443,7 @@ class HashCache {
     this.cache = new Map;
   }
   get(filePath) {
-    const stats = fs2.statSync(filePath);
+    const stats = statSync2(filePath);
     const cached = this.cache.get(filePath);
     if (cached && cached.mtime === stats.mtimeMs && cached.size === stats.size) {
       return cached.hash;
@@ -24451,7 +24451,7 @@ class HashCache {
     return;
   }
   set(filePath, hash2) {
-    const stats = fs2.statSync(filePath);
+    const stats = statSync2(filePath);
     this.cache.set(filePath, {
       hash: hash2,
       mtime: stats.mtimeMs,
@@ -27125,8 +27125,8 @@ class REPL {
     if (!this.options.historyFile)
       return;
     try {
-      const fs3 = await import("node:fs/promises");
-      const data = await fs3.readFile(this.options.historyFile, "utf-8");
+      const fs = await import("node:fs/promises");
+      const data = await fs.readFile(this.options.historyFile, "utf-8");
       this.history.commands = data.split(`
 `).filter((line) => line.trim());
       this.historyIndex = this.history.commands.length;
@@ -27136,8 +27136,8 @@ class REPL {
     if (!this.options.historyFile)
       return;
     try {
-      const fs3 = await import("node:fs/promises");
-      await fs3.writeFile(this.options.historyFile, this.history.commands.join(`
+      const fs = await import("node:fs/promises");
+      await fs.writeFile(this.options.historyFile, this.history.commands.join(`
 `));
     } catch (error) {
       console.error(`Failed to save history: ${error}`);
@@ -27173,8 +27173,8 @@ class REPLContext {
   clear() {
     this.variables.clear();
   }
-  setWorkingDirectory(path3) {
-    this.workingDirectory = path3;
+  setWorkingDirectory(path) {
+    this.workingDirectory = path;
   }
   getWorkingDirectory() {
     return this.workingDirectory;
@@ -27291,9 +27291,9 @@ class CommandHistory {
     if (!this.persistFile)
       return;
     try {
-      const fs3 = await import("node:fs/promises");
+      const fs = await import("node:fs/promises");
       const data = JSON.stringify(this.entries, null, 2);
-      await fs3.writeFile(this.persistFile, data, "utf-8");
+      await fs.writeFile(this.persistFile, data, "utf-8");
     } catch (error) {
       throw new Error(`Failed to save history: ${error}`);
     }
@@ -27302,8 +27302,8 @@ class CommandHistory {
     if (!this.persistFile)
       return;
     try {
-      const fs3 = await import("node:fs/promises");
-      const data = await fs3.readFile(this.persistFile, "utf-8");
+      const fs = await import("node:fs/promises");
+      const data = await fs.readFile(this.persistFile, "utf-8");
       const parsed = JSON.parse(data);
       this.entries = parsed.map((entry) => ({
         ...entry,
@@ -30721,14 +30721,14 @@ class CloudTrailManager {
     if (trail.advancedEventSelectors) {
       cf.Properties.AdvancedEventSelectors = trail.advancedEventSelectors.map((selector) => ({
         Name: selector.name,
-        FieldSelectors: selector.fieldSelectors.map((fs3) => ({
-          Field: fs3.field,
-          ...fs3.equals && { Equals: fs3.equals },
-          ...fs3.startsWith && { StartsWith: fs3.startsWith },
-          ...fs3.endsWith && { EndsWith: fs3.endsWith },
-          ...fs3.notEquals && { NotEquals: fs3.notEquals },
-          ...fs3.notStartsWith && { NotStartsWith: fs3.notStartsWith },
-          ...fs3.notEndsWith && { NotEndsWith: fs3.notEndsWith }
+        FieldSelectors: selector.fieldSelectors.map((fs) => ({
+          Field: fs.field,
+          ...fs.equals && { Equals: fs.equals },
+          ...fs.startsWith && { StartsWith: fs.startsWith },
+          ...fs.endsWith && { EndsWith: fs.endsWith },
+          ...fs.notEquals && { NotEquals: fs.notEquals },
+          ...fs.notStartsWith && { NotStartsWith: fs.notStartsWith },
+          ...fs.notEndsWith && { NotEndsWith: fs.notEndsWith }
         }))
       }));
     }
@@ -40243,8 +40243,8 @@ The {{appName}} Team`,
     });
     return result;
   }
-  static getNestedValue(obj, path3) {
-    return path3.split(".").reduce((current, key) => current?.[key], obj);
+  static getNestedValue(obj, path) {
+    return path.split(".").reduce((current, key) => current?.[key], obj);
   }
   static extractVariables(template) {
     const variables = new Set;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ts-cloud/core",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "type": "module",
   "description": "Core CloudFormation generation library for ts-cloud",
   "author": "Chris Breuer <chris@stacksjs.com>",
@@ -31,7 +31,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@ts-cloud/aws-types": "0.2.6"
+    "@ts-cloud/aws-types": "0.2.8"
   },
   "devDependencies": {
     "typescript": "^5.9.3"