latticesql 4.3.1 → 4.3.3

package/dist/index.cjs

@@ -917,7 +917,7 @@ async function registerPostgresPolyfills(run) {
       await run(sql);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      if (/permission denied/i.test(msg)) {
+      if (/permission denied/i.test(msg) || /must be owner of/i.test(msg)) {
         permissionDenied = true;
       } else {
         console.warn(`[PostgresAdapter] ${warn}`, msg);
@@ -1439,40 +1439,111 @@ var init_postgres = __esm({
             SELECT doc::jsonb #>> string_to_array(regexp_replace(path, '^\\$\\.?', ''), '.')
           $fn$;
       END IF;
+    END $do$;`
+      },
+      {
+        warn: "could not register strftime format helper:",
+        // Shared format translator (SQLite strftime tokens → to_char patterns), in UTC.
+        // Factored out so the 2-arg and 3-arg strftime overloads share one definition.
+        // Each polyfill below is CREATE OR REPLACE (so an existing cloud's prior copy is
+        // UPGRADED when the owner opens), wrapped in a DO block whose EXCEPTION swallows a
+        // scoped member's insufficient-privilege failure IN A SUBTRANSACTION — so a member
+        // that runs registration inside a transaction is NOT aborted. ("must be owner of
+        // function", raised when a non-owner CREATE OR REPLACEs another role's function, is
+        // SQLSTATE 42501 / `insufficient_privilege`, same class as "permission denied".) The
+        // owner already owns + replaced the function; the member simply uses the owner's
+        // copy — and `ownPolyfillsByGroup` re-owns the whole set to the member group so any
+        // member can replace them on a later upgrade.
+        sql: `DO $do$ BEGIN
+      CREATE OR REPLACE FUNCTION __lattice_strftime_fmt(ts timestamptz, format text)
+        RETURNS text
+        LANGUAGE sql
+        IMMUTABLE
+        AS $fn$
+          SELECT to_char(
+            ts AT TIME ZONE 'UTC',
+            replace(replace(replace(replace(replace(replace(replace(replace(
+              format,
+              '%Y', 'YYYY'),
+              '%m', 'MM'),
+              '%d', 'DD'),
+              '%H', 'HH24'),
+              '%M', 'MI'),
+              '%S', 'SS'),
+              '%f', 'MS'),
+              'T', '"T"')
+          );
+        $fn$;
+    EXCEPTION WHEN insufficient_privilege THEN NULL;
     END $do$;`
       },
       {
         warn: "could not register strftime polyfill:",
+        // The pre-4.3.3 strftime cast the modifier straight to timestamptz and threw
+        // `invalid input syntax for type timestamp with time zone: ""` on a legacy ''
+        // value (3.x stored nullable TEXT timestamps as ''), bricking the whole workspace
+        // open. Now an empty, whitespace, or unparseable time string returns NULL (SQLite's
+        // strftime semantics) instead of aborting the query.
         sql: `DO $do$ BEGIN
-      IF to_regprocedure('strftime(text, text)') IS NULL THEN
-        CREATE FUNCTION strftime(format text, modifier text)
-          RETURNS text
-          LANGUAGE plpgsql
-          IMMUTABLE
-          AS $fn$
-          DECLARE ts timestamptz;
-          BEGIN
-            IF modifier = 'now' THEN
-              ts := now();
-            ELSE
+      CREATE OR REPLACE FUNCTION strftime(format text, modifier text)
+        RETURNS text
+        LANGUAGE plpgsql
+        IMMUTABLE
+        AS $fn$
+        DECLARE ts timestamptz;
+        BEGIN
+          IF modifier = 'now' THEN
+            ts := now();
+          ELSIF NULLIF(btrim(modifier), '') IS NULL THEN
+            RETURN NULL;
+          ELSE
+            BEGIN
               ts := modifier::timestamptz;
-            END IF;
-            RETURN to_char(
-              ts AT TIME ZONE 'UTC',
-              replace(replace(replace(replace(replace(replace(replace(replace(
-                format,
-                '%Y', 'YYYY'),
-                '%m', 'MM'),
-                '%d', 'DD'),
-                '%H', 'HH24'),
-                '%M', 'MI'),
-                '%S', 'SS'),
-                '%f', 'MS'),
-                'T', '"T"')
-            );
+            EXCEPTION WHEN others THEN
+              RETURN NULL;
+            END;
+          END IF;
+          RETURN __lattice_strftime_fmt(ts, format);
+        END;
+        $fn$;
+    EXCEPTION WHEN insufficient_privilege THEN NULL;
+    END $do$;`
+      },
+      {
+        warn: "could not register 3-arg strftime polyfill:",
+        // SQLite's 3-arg strftime(format, timestring, modifier) — used by the changelog
+        // retention prune (e.g. strftime('%Y-...','now','-30 days')). Postgres had no
+        // 3-arg overload, so that prune threw `function strftime(...) does not exist` on
+        // every PG cloud with retention. Resolve the base time, apply the modifier as an
+        // interval, then reuse the shared formatter. Empty/invalid → NULL, never throws.
+        sql: `DO $do$ BEGIN
+      CREATE OR REPLACE FUNCTION strftime(format text, timestring text, modifier text)
+        RETURNS text
+        LANGUAGE plpgsql
+        IMMUTABLE
+        AS $fn$
+        DECLARE ts timestamptz;
+        BEGIN
+          IF timestring = 'now' THEN
+            ts := now();
+          ELSIF NULLIF(btrim(timestring), '') IS NULL THEN
+            RETURN NULL;
+          ELSE
+            BEGIN
+              ts := timestring::timestamptz;
+            EXCEPTION WHEN others THEN
+              RETURN NULL;
+            END;
+          END IF;
+          BEGIN
+            ts := ts + modifier::interval;
+          EXCEPTION WHEN others THEN
+            RETURN NULL;
           END;
-          $fn$;
-      END IF;
+          RETURN __lattice_strftime_fmt(ts, format);
+        END;
+        $fn$;
+    EXCEPTION WHEN insufficient_privilege THEN NULL;
     END $do$;`
       }
     ];
@@ -9391,7 +9462,12 @@ CREATE TRIGGER "${trg}" AFTER INSERT OR UPDATE OR DELETE ON ${q3}
 async function ownPolyfillsByGroup(db) {
   if (!isPg(db)) return;
   const group3 = await memberGroupFor(db);
-  for (const sig of ["json_extract(text, text)", "strftime(text, text)"]) {
+  for (const sig of [
+    "json_extract(text, text)",
+    "strftime(text, text)",
+    "strftime(text, text, text)",
+    "__lattice_strftime_fmt(timestamptz, text)"
+  ]) {
     try {
       const reg = await getAsyncOrSync(db.adapter, `SELECT to_regprocedure($1) AS reg`, [sig]);
       if (reg?.reg == null) continue;
@@ -23491,12 +23567,12 @@ var init_getNodeModulesParentDirs = __esm({
   "node_modules/@aws-sdk/core/dist-es/submodules/client/util-user-agent-node/getNodeModulesParentDirs.js"() {
     "use strict";
     import_node_path21 = require("path");
-    getNodeModulesParentDirs = (dirname18) => {
+    getNodeModulesParentDirs = (dirname19) => {
       const cwd = process.cwd();
-      if (!dirname18) {
+      if (!dirname19) {
         return [cwd];
       }
-      const normalizedPath = (0, import_node_path21.normalize)(dirname18);
+      const normalizedPath = (0, import_node_path21.normalize)(dirname19);
       const parts = normalizedPath.split(import_node_path21.sep);
       const nodeModulesIndex = parts.indexOf("node_modules");
       const parentDir = nodeModulesIndex !== -1 ? parts.slice(0, nodeModulesIndex).join(import_node_path21.sep) : normalizedPath;
@@ -23574,8 +23650,8 @@ var init_getTypeScriptUserAgentPair = __esm({
         tscVersion = null;
         return void 0;
       }
-      const dirname18 = typeof __dirname !== "undefined" ? __dirname : void 0;
-      const nodeModulesParentDirs = getNodeModulesParentDirs(dirname18);
+      const dirname19 = typeof __dirname !== "undefined" ? __dirname : void 0;
+      const nodeModulesParentDirs = getNodeModulesParentDirs(dirname19);
       let versionFromApp;
       for (const nodeModulesParentDir of nodeModulesParentDirs) {
         try {
@@ -80292,20 +80368,49 @@ var MAX_LIST_ENTRIES = 2e3;
 var MAX_INGEST_FILES = 500;
 var MAX_INGEST_DEPTH = 8;
 var SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", ".DS_Store", "__pycache__", ".venv", "venv"]);
-function rootsFile() {
-  return (0, import_node_path44.join)(configDir(), "sources.json");
+function rootsFile(configPath) {
+  return (0, import_node_path44.join)((0, import_node_path44.dirname)(configPath), "sources.json");
+}
+function migrateGlobalRootsIfNeeded(configPath) {
+  const wsFile = rootsFile(configPath);
+  if ((0, import_node_fs41.existsSync)(wsFile)) return;
+  const globalFile = (0, import_node_path44.join)(configDir(), "sources.json");
+  if (globalFile === wsFile || !(0, import_node_fs41.existsSync)(globalFile)) return;
+  let roots;
+  try {
+    const parsed = JSON.parse((0, import_node_fs41.readFileSync)(globalFile, "utf8"));
+    if (!Array.isArray(parsed.roots) || parsed.roots.length === 0) return;
+    roots = parsed.roots;
+  } catch {
+    return;
+  }
+  try {
+    (0, import_node_fs41.mkdirSync)((0, import_node_path44.dirname)(wsFile), { recursive: true });
+    (0, import_node_fs41.writeFileSync)(wsFile, JSON.stringify({ roots }, null, 2), "utf8");
+  } catch {
+    return;
+  }
+  try {
+    (0, import_node_fs41.rmSync)(globalFile, { force: true });
+  } catch {
+    try {
+      (0, import_node_fs41.writeFileSync)(globalFile, JSON.stringify({ roots: [] }, null, 2), "utf8");
+    } catch {
+    }
+  }
 }
-function readRoots() {
+function readRoots(configPath) {
+  migrateGlobalRootsIfNeeded(configPath);
   try {
-    const raw = (0, import_node_fs41.readFileSync)(rootsFile(), "utf8");
+    const raw = (0, import_node_fs41.readFileSync)(rootsFile(configPath), "utf8");
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed.roots) ? parsed.roots : [];
   } catch {
     return [];
   }
 }
-function writeRoots(roots) {
-  (0, import_node_fs41.writeFileSync)(rootsFile(), JSON.stringify({ roots }, null, 2), "utf8");
+function writeRoots(configPath, roots) {
+  (0, import_node_fs41.writeFileSync)(rootsFile(configPath), JSON.stringify({ roots }, null, 2), "utf8");
 }
 function safeResolveInside2(target, roots) {
   const abs = (0, import_node_path44.resolve)(target);
@@ -80395,14 +80500,14 @@ async function ingestFolder(abs, ingestFile) {
   return { ingested, skipped };
 }
 async function dispatchSourcesRoute(req, res, deps) {
-  const { pathname, method, ingestFile } = deps;
+  const { pathname, method, ingestFile, configPath } = deps;
   if (!pathname.startsWith("/api/sources/")) return false;
   if (!localFileOpenEnabled()) {
     sendJson(res, { enabled: false });
     return true;
   }
   if (pathname === "/api/sources/roots" && method === "GET") {
-    sendJson(res, { enabled: true, roots: readRoots() });
+    sendJson(res, { enabled: true, roots: readRoots(configPath) });
     return true;
   }
   if (pathname === "/api/sources/roots" && method === "POST") {
@@ -80428,12 +80533,12 @@ async function dispatchSourcesRoute(req, res, deps) {
       sendJson(res, { error: `path not found: ${abs}` }, 400);
       return true;
     }
-    const roots = readRoots();
+    const roots = readRoots(configPath);
     let root6 = roots.find((r6) => (0, import_node_path44.resolve)(r6.path) === abs);
     if (!root6) {
       root6 = { id: (0, import_node_crypto24.randomUUID)(), path: abs, kind, name: (0, import_node_path44.basename)(abs) || abs };
       roots.push(root6);
-      writeRoots(roots);
+      writeRoots(configPath, roots);
     }
     let result;
     if (kind === "folder") result = await ingestFolder(abs, ingestFile);
@@ -80444,8 +80549,8 @@ async function dispatchSourcesRoute(req, res, deps) {
   const delMatch = /^\/api\/sources\/roots\/([^/]+)$/.exec(pathname);
   if (delMatch && method === "DELETE") {
     const id = decodeURIComponent(delMatch[1] ?? "");
-    const roots = readRoots().filter((r6) => r6.id !== id);
-    writeRoots(roots);
+    const roots = readRoots(configPath).filter((r6) => r6.id !== id);
+    writeRoots(configPath, roots);
     sendJson(res, { ok: true });
     return true;
   }
@@ -80463,7 +80568,7 @@ async function dispatchSourcesRoute(req, res, deps) {
       sendJson(res, { error: "path is required" }, 400);
       return true;
     }
-    const abs = safeResolveInside2(target, readRoots());
+    const abs = safeResolveInside2(target, readRoots(configPath));
     if (!abs) {
       sendJson(res, { error: "path is outside any registered source root" }, 403);
       return true;
@@ -80478,7 +80583,7 @@ async function dispatchSourcesRoute(req, res, deps) {
   if (pathname === "/api/sources/ingest-folder" && method === "POST") {
     const body = await readJson(req).catch(() => ({}));
     const target = typeof body.path === "string" ? body.path : "";
-    const abs = safeResolveInside2(target, readRoots());
+    const abs = safeResolveInside2(target, readRoots(configPath));
     if (!abs) {
       sendJson(res, { error: "path is outside any registered source root" }, 403);
       return true;
@@ -83117,6 +83222,7 @@ async function startGuiServer(options) {
               return await dispatchSourcesRoute(req2, res2, {
                 db: active.db,
                 ingestFile: (p3) => ingestLocalFile(ingestCtx, mctx, p3, false),
+                configPath: active.configPath,
                 pathname,
                 method
               });