Merge branch 'main' of github.com:devforth/adminforth into feature/AdminForth/1647/do-not-create-a-prism-if-the-d

Author: NoOne7135

adminforth/dataConnectors/baseConnector.ts

@@ -44,7 +44,7 @@ export default class AdminForthBaseConnector implements IAdminForthDataSourceCon
     return this.client;
   }
 
-  setupClient(url: string): Promise<void> {
+  setupClient(url: string, options?: { recovery?: boolean }): Promise<void> {
     throw new Error('Method not implemented.');
   }
 

adminforth/dataConnectors/postgres.ts

@@ -16,20 +16,35 @@ types.setTypeParser(1082, (val) => val); // DATE
 
 class PostgresConnector extends AdminForthBaseConnector implements IAdminForthDataSourceConnector {
 
-    async setupClient(url: string): Promise<void> {
+    async setupClient(url: string, options?: { recovery?: boolean }): Promise<void> {
         this.client = new Pool({
             connectionString: url
         });
-        try {
-            await this.client.connect();
-            this.client.on('error', async (err) => {
-                afLogger.error(`Postgres error: ${err.message} ${err.stack}`);
-                this.client.end();
-                await new Promise((resolve) => { setTimeout(resolve, 1000) });
-                this.setupClient(url);
+
+        const selfHeal = options?.recovery !== false;
+
+        if (selfHeal) {
+            this.client.on('error', (err) => {
+                afLogger.error(`Postgres pool idle client error (pool self-heals on next query): ${err.message} ${err.stack}`);
             });
-        } catch (e) {
-            afLogger.error(`Failed to connect to Postgres ${e}`);
+            try {
+                const client = await this.client.connect();
+                client.release();
+            } catch (e) {
+                afLogger.error(`Failed to connect to Postgres ${e}`);
+            }
+        } else {
+            try {
+                await this.client.connect();
+                this.client.on('error', async (err) => {
+                    afLogger.error(`Postgres error: ${err.message} ${err.stack}`);
+                    this.client.end();
+                    await new Promise((resolve) => { setTimeout(resolve, 1000) });
+                    this.setupClient(url, options);
+                });
+            } catch (e) {
+                afLogger.error(`Failed to connect to Postgres ${e}`);
+            }
         }
     }
 

adminforth/documentation/docs/tutorial/02-glossary.md

@@ -15,6 +15,25 @@ It used to:
 
 There might be several datasources in the system for various databases e.g. One datasource to Mongo DBs and one to Postgres DB. 
 
+### connectionRecovery
+
+For PostgreSQL datasources AdminForth keeps a connection pool. The optional `connectionRecovery` flag controls how the connector reacts when that connection drops (DB restart, failover, network blip, etc.):
+
+```ts
+dataSources: [
+  {
+    id: 'maindb',
+    url: `${process.env.DATABASE_URL}`,
+    connectionRecovery: true, // default
+  },
+],
+```
+
+- `true` (default, recommended) — **self-heal mode.** The pool recovers automatically: a dead idle connection is dropped and a fresh one is transparently opened on the next query, so the app keeps working without a manual restart. Queries that were in-flight at the moment of the outage will fail, but subsequent queries succeed once the database is back.
+- `false` — **legacy mode.** On a connection error the pool is destroyed and recreated after 1 second. If the outage outlasts that retry, the app can be left with a permanently dead pool and require a manual restart. Kept only for backward compatibility.
+
+This flag is currently honored by the PostgreSQL connector; other connectors rely on their driver's built-in recovery.
+
 ## resource
 
 A [Resource](/docs/api/Back/interfaces/AdminForthResource.md) is a AdminForth representation of a table or collection in database. One resource is one table in the database. Resource has `table` property which should be equal to the name of the table in the database.

adminforth/documentation/docs/tutorial/03-Customization/16-websocket.md

@@ -13,10 +13,13 @@ In two words, to subscribe to a topic from any frontend component you need to do
 ```javascript
 import websocket from '@/websocket';
 
-websocket.subscribe('/topic-name', (data) => {
+const unsubscribe = websocket.subscribe('/topic-name', (data) => {
   // this callback called when we receive publish in topic from the websocket
   console.log(data);
 });
+
+// later, for example when the component is unmounted
+unsubscribe();
 ```
 
 On server you can publish data to the topic by calling
@@ -74,17 +77,17 @@ const props = defineProps({
 });
 
 const totalCost: Ref<number|null> = ref(null);
+let unsubscribePropertyCost: (() => void) | undefined;
 
 onMounted(() => {
-  websocket.subscribe(`/property-cost/${props.adminUser!.pk}`, (data: any) => {
+  unsubscribePropertyCost = websocket.subscribe(`/property-cost/${props.adminUser!.pk}`, (data: any) => {
     // this callback called when we receive publish in topic from the websocket
     totalCost.value = data.totalCost;
   });
 });
 
 onUnmounted(() => {
-  // will be called on logout
-  websocket.unsubscribeAll();
+  unsubscribePropertyCost?.();
 });
 
 </script>
@@ -258,4 +261,4 @@ admin.websocket.publish(topic, { type: 'message', totalCost }, async (adminUser:
 
 ```
 
-In this case during publish call it will check all users who subscribed to the topic and do actual publish to only those who are allowed to receive the message. This method requires more CPU resources and generally is not recommended.
+In this case during publish call it will check all users who subscribed to the topic and do actual publish to only those who are allowed to receive the message. This method requires more CPU resources and generally is not recommended.

adminforth/documentation/docs/tutorial/05-Adapters/05-ai-completion-adapters.md

@@ -129,7 +129,7 @@ new CompletionAdapterOpenAIResponses({
 
 You can specify any GPT model you need. The default is `gpt-5-nano` as it is cheapest though may behave weakly.
 
-By default, this adapter uses the OpenAI `responses` API (`v1/responses`) unless `useComplitionApi` is set to `true`. If `useComplitionApi` is `true`, it uses the older Chat Completions API (`v1/chat/completions`). 
+By default, this adapter uses the OpenAI `responses` API (`v1/responses`) unless `useCompletionApi` is set to `true`. If `useCompletionApi` is `true`, it uses the older Chat Completions API (`v1/chat/completions`). 
 
 
 ### Using with OpenAI-compatible API providers (for example based on self-hosted vLLM docker images)
@@ -141,25 +141,25 @@ new CompletionAdapterOpenAIResponses({
   openAiApiKey: process.env.OVH_AI_ENDPOINTS_ACCESS_TOKEN as string,
   baseUrl: 'https://oai.endpoints.kepler.ai.cloud.ovh.net/v1',
   model: 'gpt-oss-20b',
-  useComplitionApi: true,
+  useCompletionApi: true,
   extraRequestBodyParameters: {
     store: false,
   },
 }),
 ```
 
-If `useComplitionApi` is omitted, the adapter keeps the current default behavior:
+If `useCompletionApi` is omitted, the adapter keeps the current default behavior:
 
 - official OpenAI uses the `responses` API
 - custom `baseUrl` providers use the Chat Completions API. 
 
-This is because many OpenAI-compatible providers do not yet support the `responses` API or support it unstably (for example OVH AI Endpoints still - Apr 2026 does not fully support the `responses`, so `useComplitionApi: false` may work unstably there, though you can re-test it by manually enabling it by setting `useComplitionApi: true` and checking if it works).
+This is because many OpenAI-compatible providers do not yet support the `responses` API or support it unstably (for example OVH AI Endpoints still - Apr 2026 does not fully support the `responses`, so `useCompletionApi: false` may work unstably there, though you can re-test it by manually enabling it by setting `useCompletionApi: true` and checking if it works).
 Any 3rd-party API providers might have next reasones of pure `responses` API compatibility:
 
 1) If they use vLLM open-source software under the hood they might have outdated version
 2) Custom non-vLLM implmentation might have reliable chat API implementation while give less priority to responses API as it is more complex and new.
 
-We recommend you to try responses API first by setting `false` in `useComplitionApi` because it gives rich features set, including summarization and better structured outputs, and if it does not work for your provider, then set it to `true` to have less features but working implementation.
+We recommend you to try responses API first by setting `false` in `useCompletionApi` because it gives rich features set, including summarization and better structured outputs, and if it does not work for your provider, then set it to `true` to have less features but working implementation.