npm - latticesql - Versions diffs - 4.3.2 → 4.3.3 - Mend

latticesql 4.3.2 → 4.3.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/cli.js CHANGED Viewed

@@ -1704,7 +1704,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);
@@ -2222,40 +2222,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$;`
       }
     ];
@@ -9180,7 +9251,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;
@@ -82020,7 +82096,7 @@ function printHelp() {
   );
 }
 function getVersion() {
-  if (true) return "4.3.2";
+  if (true) return "4.3.3";
   try {
     const pkgPath = new URL("../package.json", import.meta.url).pathname;
     const pkg = JSON.parse(readFileSync26(pkgPath, "utf-8"));

package/dist/desktop-entry.js CHANGED Viewed

@@ -835,7 +835,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;
@@ -1781,7 +1786,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);
@@ -2299,40 +2304,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$;`
       }
     ];
@@ -81598,7 +81674,7 @@ ${e6.stack ?? ""}`
 }
 // src/desktop-entry.ts
-var VERSION2 = true ? "4.3.2" : "unknown";
+var VERSION2 = true ? "4.3.3" : "unknown";
 export {
   VERSION2 as VERSION,
   ensureRootForGui,

package/dist/index.cjs CHANGED Viewed

@@ -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;

package/dist/index.js CHANGED Viewed

@@ -909,7 +909,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);
@@ -1427,40 +1427,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$;`
       }
     ];
@@ -9397,7 +9468,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;

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "latticesql",
-  "version": "4.3.2",
+  "version": "4.3.3",
   "description": "Persistent structured memory for AI agent systems — pluggable SQLite or Postgres backend, LLM context bridge",
   "type": "module",
   "main": "./dist/index.js",