@deepagents/text2sql 7.1.1 → 7.1.2

package/README.md

@@ -452,10 +452,8 @@ callers wait. When each waiter gets the key, its `index()` call reads the cache
 that the first caller wrote.
 
 `SqliteStore` shares keys between the processes on one host. For a fleet of
-hosts, acquire the key from a service that all hosts share, and give all hosts
-the same cache. `demo/text2sql-daemon` uses a Postgres advisory lock for the
-key and a `FileIndexCache` from `TEXT2SQL_INDEX_CACHE_DIR` /
-`TEXT2SQL_INDEX_VERSION`.
+hosts, acquire the key from a service that all hosts share, for example a
+Postgres advisory lock, and give all hosts the same cache.
 
 > On object-storage-backed volumes (GCS/S3 FUSE) `rename` is not atomic. The
 > `FileIndexCache` parse-as-miss behavior tolerates a torn write: the next

package/dist/index.js

@@ -2347,7 +2347,6 @@ var MssqlFs = class _MssqlFs {
   #root;
   #schema;
   #ownsPool;
-  #isInitialized = false;
   constructor(options) {
     this.#chunkSize = options.chunkSize ?? 1024 * 1024;
     const schema = options.schema ?? "dbo";
@@ -2379,7 +2378,18 @@ var MssqlFs = class _MssqlFs {
   #t(name) {
     return `[${this.#schema}].[${name}]`;
   }
-  async initialize() {
+  /** Opens the file system: creates its tables and its root directories. */
+  static async create(options) {
+    const fs = new _MssqlFs(options);
+    try {
+      await fs.#initialize();
+    } catch (error) {
+      await fs.close();
+      throw error;
+    }
+    return fs;
+  }
+  async #initialize() {
     if (this.#ownsPool) {
       await this.#pool.connect();
     }
@@ -2401,12 +2411,12 @@ var MssqlFs = class _MssqlFs {
     }
     const rootSlashExists = rowsOf(
       existsRow,
-      await this.#rawQuery(
+      await this.#query(
         `SELECT CASE WHEN EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = '/') THEN 1 ELSE 0 END as [exists]`
       )
     );
     if (rootSlashExists[0].exists === 0) {
-      await this.#rawExec(
+      await this.#exec(
         `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime) VALUES ('/', 'directory', 493, 0, @p0)`,
         [Date.now()]
       );
@@ -2415,26 +2425,18 @@ var MssqlFs = class _MssqlFs {
       await this.#createParentDirs(this.#root);
       const rootExists = rowsOf(
         existsRow,
-        await this.#rawQuery(
+        await this.#query(
           `SELECT CASE WHEN EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = @p0) THEN 1 ELSE 0 END as [exists]`,
           [this.#root]
         )
       );
       if (rootExists[0].exists === 0) {
-        await this.#rawExec(
+        await this.#exec(
           `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime) VALUES (@p0, 'directory', 493, 0, @p1)`,
           [this.#root, Date.now()]
         );
       }
     }
-    this.#isInitialized = true;
-  }
-  #ensureInitialized() {
-    if (!this.#isInitialized) {
-      throw new Error(
-        "MssqlFs not initialized. Call await fs.initialize() after construction."
-      );
-    }
   }
   async #createParentDirs(p) {
     const segments = p.split("/").filter(Boolean);
@@ -2443,27 +2445,27 @@ var MssqlFs = class _MssqlFs {
       currentPath = path3.posix.join(currentPath, segments[i]);
       const exists = rowsOf(
         existsRow,
-        await this.#rawQuery(
+        await this.#query(
           `SELECT CASE WHEN EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = @p0) THEN 1 ELSE 0 END as [exists]`,
           [currentPath]
         )
       );
       if (exists[0].exists === 0) {
-        await this.#rawExec(
+        await this.#exec(
           `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime) VALUES (@p0, 'directory', 493, 0, @p1)`,
           [currentPath, Date.now()]
         );
       }
     }
   }
-  #rawQuery(sql, params) {
+  #query(sql, params) {
     const request = this.#pool.request();
     params?.forEach((value, index2) => {
       request.input(`p${index2}`, value);
     });
     return request.query(sql);
   }
-  async #rawExec(sql, params) {
+  async #exec(sql, params) {
     const request = this.#pool.request();
     params?.forEach((value, index2) => {
       request.input(`p${index2}`, value);
@@ -2471,16 +2473,7 @@ var MssqlFs = class _MssqlFs {
     const result = await request.query(sql);
     return result.rowsAffected[0] ?? 0;
   }
-  async #query(sql, params) {
-    this.#ensureInitialized();
-    return this.#rawQuery(sql, params);
-  }
-  async #exec(sql, params) {
-    this.#ensureInitialized();
-    return this.#rawExec(sql, params);
-  }
   async #useTransaction(fn) {
-    this.#ensureInitialized();
     const mssql = _MssqlFs.#requireMssql();
     const transaction = new mssql.Transaction(this.#pool);
     try {
@@ -3433,7 +3426,6 @@ var PostgresFs = class _PostgresFs {
   #root;
   #schema;
   #ownsPool;
-  #isInitialized = false;
   constructor(options) {
     this.#chunkSize = options.chunkSize ?? 1024 * 1024;
     const schema = options.schema ?? "public";
@@ -3465,17 +3457,28 @@ var PostgresFs = class _PostgresFs {
   #t(name) {
     return `"${this.#schema}"."${name}"`;
   }
-  async initialize() {
+  /** Opens the file system: creates its tables and its root directories. */
+  static async create(options) {
+    const fs = new _PostgresFs(options);
+    try {
+      await fs.#initialize();
+    } catch (error) {
+      await fs.close();
+      throw error;
+    }
+    return fs;
+  }
+  async #initialize() {
     const ddl = postgresFsDDL(this.#schema);
     await this.#pool.query(ddl);
     const rootSlashExists = rowsOf2(
       existsRow2,
-      await this.#rawQuery(
+      await this.#query(
         `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = '/') AS exists`
       )
     );
     if (!rootSlashExists[0].exists) {
-      await this.#rawExec(
+      await this.#exec(
         `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime) VALUES ('/', 'directory', 493, 0, $1)`,
         [Date.now()]
       );
@@ -3484,26 +3487,18 @@ var PostgresFs = class _PostgresFs {
       await this.#createParentDirs(this.#root);
       const rootExists = rowsOf2(
         existsRow2,
-        await this.#rawQuery(
+        await this.#query(
           `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = $1) AS exists`,
           [this.#root]
         )
       );
       if (!rootExists[0].exists) {
-        await this.#rawExec(
+        await this.#exec(
           `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime) VALUES ($1, 'directory', 493, 0, $2)`,
           [this.#root, Date.now()]
         );
       }
     }
-    this.#isInitialized = true;
-  }
-  #ensureInitialized() {
-    if (!this.#isInitialized) {
-      throw new Error(
-        "PostgresFs not initialized. Call await fs.initialize() after construction."
-      );
-    }
   }
   async #createParentDirs(p) {
     const segments = p.split("/").filter(Boolean);
@@ -3512,36 +3507,27 @@ var PostgresFs = class _PostgresFs {
       currentPath = path4.posix.join(currentPath, segments[i]);
       const exists = rowsOf2(
         existsRow2,
-        await this.#rawQuery(
+        await this.#query(
           `SELECT EXISTS(SELECT 1 FROM ${this.#t("fs_entries")} WHERE path = $1) AS exists`,
           [currentPath]
         )
       );
       if (!exists[0].exists) {
-        await this.#rawExec(
+        await this.#exec(
           `INSERT INTO ${this.#t("fs_entries")} (path, type, mode, size, mtime) VALUES ($1, 'directory', 493, 0, $2)`,
           [currentPath, Date.now()]
         );
       }
     }
   }
-  #rawQuery(sql, params) {
+  #query(sql, params) {
     return this.#pool.query(sql, params);
   }
-  async #rawExec(sql, params) {
+  async #exec(sql, params) {
     const result = await this.#pool.query(sql, params);
     return result.rowCount ?? 0;
   }
-  async #query(sql, params) {
-    this.#ensureInitialized();
-    return this.#rawQuery(sql, params);
-  }
-  async #exec(sql, params) {
-    this.#ensureInitialized();
-    return this.#rawExec(sql, params);
-  }
   async #useTransaction(fn) {
-    this.#ensureInitialized();
     const client = await this.#pool.connect();
     try {
       await client.query("BEGIN");