prostgles-server 4.2.179 → 4.2.180

package/documentation/utils/dist/serverTypes.d.ts

@@ -0,0 +1,307 @@
+export declare const definitions: [{
+    readonly type: "object";
+    readonly alias: "ProstglesInitOptions<S, SUser>";
+    readonly aliasSymbolescapedName: "ProstglesInitOptions";
+    readonly comments: "";
+    readonly properties: {
+        readonly dbConnection: {
+            readonly type: "union";
+            readonly alias: "DbConnection";
+            readonly aliasSymbolescapedName: "DbConnection";
+            readonly comments: "Database connection details";
+            readonly types: [{
+                readonly type: "primitive";
+                readonly alias: "string";
+                readonly subType: "string";
+            }, {
+                readonly type: "reference";
+                readonly alias: "IConnectionParameters<IClient>";
+            }];
+            readonly optional: false;
+        };
+        readonly onReady: {
+            readonly type: "function";
+            readonly alias: "OnReadyCallback<S>";
+            readonly aliasSymbolescapedName: "OnReadyCallback";
+            readonly arguments: [{
+                readonly name: "params";
+                readonly optional: false;
+                readonly type: "reference";
+                readonly alias: "OnReadyParams<S>";
+                readonly aliasSymbolescapedName: "OnReadyParams";
+                readonly comments: "";
+            }];
+            readonly returnType: {
+                readonly type: "primitive";
+                readonly alias: "any";
+                readonly subType: "any";
+            };
+            readonly optional: false;
+            readonly comments: "Called when the prostgles server is ready to accept connections.\nIt waits for auth, tableConfig and other async configurations to complete before executing";
+        };
+        readonly dbOptions: {
+            readonly type: "reference";
+            readonly alias: "IDefaults";
+            readonly optional: true;
+        };
+        readonly tsGeneratedTypesDir: {
+            readonly type: "reference";
+            readonly alias: "string | undefined";
+            readonly comments: "If defined then a `DBSchemaGenerated.d.ts` file will be created in the provided directory.\nThis file exports a `DBSchemaGenerated` type which contains types for the database tables and\ncan be used as a generic type input for the prostgles instances to ensure type safety";
+            readonly optional: true;
+        };
+        readonly disableRealtime: {
+            readonly type: "reference";
+            readonly alias: "boolean | undefined";
+            readonly comments: "If true then schema watch, subscriptions and syncs will be disabled.\nNo `prostgles` schema will be created which is needed for the realtime features.\nThis is useful when you want to connect to a database and prevent any changes to the schema";
+            readonly optional: true;
+        };
+        readonly io: {
+            readonly type: "reference";
+            readonly alias: "Server<DefaultEventsMap, DefaultEventsMap, DefaultEventsMap, any>";
+            readonly comments: "Socket.IO server instance object";
+            readonly optional: true;
+        };
+        readonly publish: {
+            readonly type: "union";
+            readonly alias: "Publish<S, SUser> | undefined";
+            readonly types: [{
+                readonly type: "primitive";
+                readonly alias: "undefined";
+                readonly subType: "undefined";
+            }, {
+                readonly type: "primitive";
+                readonly alias: "null";
+                readonly subType: "null";
+            }, {
+                readonly type: "reference";
+                readonly alias: "\"*\"";
+            }, {
+                readonly type: "primitive";
+                readonly alias: "PublishFullyTyped<S>";
+                readonly aliasSymbolescapedName: "PublishFullyTyped";
+                readonly subType: "any";
+            }, {
+                readonly type: "reference";
+                readonly alias: "(params: PublishParams<S, SUser>) => Awaitable<PublishedResult<S>>";
+            }, {
+                readonly type: "primitive";
+                readonly alias: "false";
+                readonly subType: "boolean";
+            }];
+            readonly optional: true;
+            readonly comments: "Data access rules applied to clients.\nBy default, nothing is allowed.";
+        };
+        readonly testRulesOnConnect: {
+            readonly type: "reference";
+            readonly alias: "boolean | undefined";
+            readonly comments: "If true then will test all table methods on each socket connect.\nNot recommended for production";
+            readonly optional: true;
+        };
+        readonly publishMethods: {
+            readonly type: "reference";
+            readonly alias: "PublishMethods<S, SUser>";
+            readonly aliasSymbolescapedName: "PublishMethods";
+            readonly comments: "Custom methods that can be called from the client";
+            readonly optional: true;
+        };
+        readonly publishRawSQL: {
+            readonly type: "reference";
+            readonly alias: "(params: PublishParams<S, SUser>) => boolean | \"*\" | Promise<boolean | \"*\">";
+            readonly comments: "If defined and resolves to true then the connected client can run SQL queries";
+            readonly optional: true;
+        };
+        readonly joins: {
+            readonly type: "union";
+            readonly alias: "Joins | undefined";
+            readonly types: [{
+                readonly type: "primitive";
+                readonly alias: "undefined";
+                readonly subType: "undefined";
+            }, {
+                readonly type: "reference";
+                readonly alias: "Join[]";
+            }, {
+                readonly type: "reference";
+                readonly alias: "\"inferred\"";
+            }];
+            readonly optional: true;
+            readonly comments: "Allows defining joins between tables:\n - `infered` - uses the foreign keys to infer the joins\n - `Join[]` - specifies the joins manually";
+        };
+        readonly schema: {
+            readonly type: "union";
+            readonly alias: "Record<string, 1> | Record<string, 0> | undefined";
+            readonly types: [{
+                readonly type: "primitive";
+                readonly alias: "undefined";
+                readonly subType: "undefined";
+            }, {
+                readonly type: "reference";
+                readonly alias: "Record<string, 1>";
+                readonly aliasSymbolescapedName: "Record";
+                readonly comments: "Construct a type with a set of properties K of type T";
+            }, {
+                readonly type: "reference";
+                readonly alias: "Record<string, 0>";
+                readonly aliasSymbolescapedName: "Record";
+                readonly comments: "Construct a type with a set of properties K of type T";
+            }];
+            readonly optional: true;
+            readonly comments: "If defined then the specified schemas are included/excluded from the prostgles schema.\nBy default the `public` schema is included.";
+        };
+        readonly sqlFilePath: {
+            readonly type: "reference";
+            readonly alias: "string | undefined";
+            readonly comments: "Path to a SQL file that will be executed on startup (but before onReady)";
+            readonly optional: true;
+        };
+        readonly transactions: {
+            readonly type: "union";
+            readonly alias: "string | boolean | undefined";
+            readonly types: [{
+                readonly type: "primitive";
+                readonly alias: "undefined";
+                readonly subType: "undefined";
+            }, {
+                readonly type: "primitive";
+                readonly alias: "string";
+                readonly subType: "string";
+            }, {
+                readonly type: "primitive";
+                readonly alias: "false";
+                readonly subType: "boolean";
+            }];
+            readonly optional: true;
+        };
+        readonly wsChannelNamePrefix: {
+            readonly type: "reference";
+            readonly alias: "string | undefined";
+            readonly optional: true;
+        };
+        readonly onSocketConnect: {
+            readonly type: "reference";
+            readonly alias: "(args: AuthRequestParams<S, SUser> & { socket: PRGLIOSocket; }) => void | Promise<void>";
+            readonly comments: "Called when a socket connects\nUse for connection verification. Will disconnect socket on any errors";
+            readonly optional: true;
+        };
+        readonly onSocketDisconnect: {
+            readonly type: "reference";
+            readonly alias: "(args: AuthRequestParams<S, SUser> & { socket: PRGLIOSocket; }) => void | Promise<void>";
+            readonly comments: "Called when a socket disconnects";
+            readonly optional: true;
+        };
+        readonly auth: {
+            readonly type: "reference";
+            readonly alias: "Auth<S, SUser>";
+            readonly aliasSymbolescapedName: "Auth";
+            readonly comments: "Auth configuration.\nSupports email and OAuth strategies";
+            readonly optional: true;
+        };
+        readonly DEBUG_MODE: {
+            readonly type: "reference";
+            readonly alias: "boolean | undefined";
+            readonly optional: true;
+        };
+        readonly onQuery: {
+            readonly type: "reference";
+            readonly alias: "(error: any, ctx: IEventContext<IClient>) => void";
+            readonly comments: "Callback called when a query is executed.\nUseful for logging or debugging";
+            readonly optional: true;
+        };
+        readonly watchSchemaType: {
+            readonly type: "union";
+            readonly alias: "\"DDL_trigger\" | \"prostgles_queries\" | undefined";
+            readonly types: [{
+                readonly type: "primitive";
+                readonly alias: "undefined";
+                readonly subType: "undefined";
+            }, {
+                readonly type: "reference";
+                readonly alias: "\"DDL_trigger\"";
+            }, {
+                readonly type: "reference";
+                readonly alias: "\"prostgles_queries\"";
+            }];
+            readonly optional: true;
+        };
+        readonly watchSchema: {
+            readonly type: "union";
+            readonly alias: "boolean | EventTriggerTagFilter | \"hotReloadMode\" | OnSchemaChangeCallback | undefined";
+            readonly types: [{
+                readonly type: "primitive";
+                readonly alias: "undefined";
+                readonly subType: "undefined";
+            }, {
+                readonly type: "reference";
+                readonly alias: "\"*\"";
+            }, {
+                readonly type: "reference";
+                readonly alias: "Partial<Record<\"ALTER AGGREGATE\" | \"ALTER COLLATION\" | \"ALTER CONVERSION\" | \"ALTER DOMAIN\" | \"ALTER DEFAULT PRIVILEGES\" | \"ALTER EXTENSION\" | \"ALTER FOREIGN DATA WRAPPER\" | \"ALTER FOREIGN TABLE\" | ... 102 more ... | \"SELECT INTO\", 1>>";
+                readonly aliasSymbolescapedName: "Partial";
+                readonly comments: "Make all properties in T optional";
+            }, {
+                readonly type: "reference";
+                readonly alias: "Partial<Record<\"ALTER AGGREGATE\" | \"ALTER COLLATION\" | \"ALTER CONVERSION\" | \"ALTER DOMAIN\" | \"ALTER DEFAULT PRIVILEGES\" | \"ALTER EXTENSION\" | \"ALTER FOREIGN DATA WRAPPER\" | \"ALTER FOREIGN TABLE\" | ... 102 more ... | \"SELECT INTO\", 0>>";
+                readonly aliasSymbolescapedName: "Partial";
+                readonly comments: "Make all properties in T optional";
+            }, {
+                readonly type: "reference";
+                readonly alias: "\"hotReloadMode\"";
+            }, {
+                readonly type: "reference";
+                readonly alias: "OnSchemaChangeCallback";
+                readonly aliasSymbolescapedName: "OnSchemaChangeCallback";
+            }, {
+                readonly type: "primitive";
+                readonly alias: "false";
+                readonly subType: "boolean";
+            }];
+            readonly optional: true;
+            readonly comments: "If truthy then DBSchemaGenerated.d.ts will be updated\nand \"onReady\" will be called with new schema on both client and server";
+        };
+        readonly keywords: {
+            readonly type: "reference";
+            readonly alias: "Keywords";
+            readonly aliasSymbolescapedName: "Keywords";
+            readonly optional: true;
+        };
+        readonly onNotice: {
+            readonly type: "reference";
+            readonly alias: "(notice: AnyObject, message?: string | undefined) => void";
+            readonly optional: true;
+        };
+        readonly fileTable: {
+            readonly type: "reference";
+            readonly alias: "FileTableConfig";
+            readonly aliasSymbolescapedName: "FileTableConfig";
+            readonly comments: "Enables file storage and serving.\nCurrently supports saving files locally or to AWS S3";
+            readonly optional: true;
+        };
+        readonly restApi: {
+            readonly type: "reference";
+            readonly alias: "RestApiConfig";
+            readonly aliasSymbolescapedName: "RestApiConfig";
+            readonly comments: "Rest API configuration.\nThe REST API allows interacting with the database similarly to the socket connection\nwith the exception of subscriptions and realtime features";
+            readonly optional: true;
+        };
+        readonly tableConfig: {
+            readonly type: "reference";
+            readonly alias: "TableConfig";
+            readonly aliasSymbolescapedName: "TableConfig";
+            readonly comments: "A simple way of defining tables through a JSON-schema like object.\nAllowes adding runtime JSONB validation and type safety.\nShould be used with caution because it tends to revert any changes\nmade to the database schema through SQL queries";
+            readonly optional: true;
+        };
+        readonly tableConfigMigrations: {
+            readonly type: "reference";
+            readonly alias: "{ silentFail?: boolean | undefined; version: number; versionTableName?: string | undefined; onMigrate: (args: { db: DB; oldVersion: number | undefined; getConstraints: (table: string, column?: string | undefined, types?: (\"c\" | ... 2 more ... | \"f\")[] | undefined) => Promise<...>; }) => void; }";
+            readonly optional: true;
+        };
+        readonly onLog: {
+            readonly type: "reference";
+            readonly alias: "(evt: EventInfo) => Promise<void>";
+            readonly comments: "Usefull for logging or debugging";
+            readonly optional: true;
+        };
+    };
+}];
+//# sourceMappingURL=serverTypes.d.ts.map

package/documentation/utils/dist/serverTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serverTypes.d.ts","sourceRoot":"","sources":["../serverTypes.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuVM,CAAC"}

package/documentation/utils/dist/serverTypes.js

@@ -0,0 +1,347 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.definitions = void 0;
+exports.definitions = [
+    {
+        "type": "object",
+        "alias": "ProstglesInitOptions<S, SUser>",
+        "aliasSymbolescapedName": "ProstglesInitOptions",
+        "comments": "",
+        "properties": {
+            "dbConnection": {
+                "type": "union",
+                "alias": "DbConnection",
+                "aliasSymbolescapedName": "DbConnection",
+                "comments": "Database connection details",
+                "types": [
+                    {
+                        "type": "primitive",
+                        "alias": "string",
+                        "subType": "string"
+                    },
+                    {
+                        "type": "reference",
+                        "alias": "IConnectionParameters<IClient>"
+                    }
+                ],
+                "optional": false
+            },
+            "onReady": {
+                "type": "function",
+                "alias": "OnReadyCallback<S>",
+                "aliasSymbolescapedName": "OnReadyCallback",
+                "arguments": [
+                    {
+                        "name": "params",
+                        "optional": false,
+                        "type": "reference",
+                        "alias": "OnReadyParams<S>",
+                        "aliasSymbolescapedName": "OnReadyParams",
+                        "comments": ""
+                    }
+                ],
+                "returnType": {
+                    "type": "primitive",
+                    "alias": "any",
+                    "subType": "any"
+                },
+                "optional": false,
+                "comments": "Called when the prostgles server is ready to accept connections.\nIt waits for auth, tableConfig and other async configurations to complete before executing"
+            },
+            "dbOptions": {
+                "type": "reference",
+                "alias": "IDefaults",
+                "optional": true
+            },
+            "tsGeneratedTypesDir": {
+                "type": "reference",
+                "alias": "string | undefined",
+                "comments": "If defined then a `DBSchemaGenerated.d.ts` file will be created in the provided directory.\nThis file exports a `DBSchemaGenerated` type which contains types for the database tables and\ncan be used as a generic type input for the prostgles instances to ensure type safety",
+                "optional": true
+            },
+            "disableRealtime": {
+                "type": "reference",
+                "alias": "boolean | undefined",
+                "comments": "If true then schema watch, subscriptions and syncs will be disabled.\nNo `prostgles` schema will be created which is needed for the realtime features.\nThis is useful when you want to connect to a database and prevent any changes to the schema",
+                "optional": true
+            },
+            "io": {
+                "type": "reference",
+                "alias": "Server<DefaultEventsMap, DefaultEventsMap, DefaultEventsMap, any>",
+                "comments": "Socket.IO server instance object",
+                "optional": true
+            },
+            "publish": {
+                "type": "union",
+                "alias": "Publish<S, SUser> | undefined",
+                "types": [
+                    {
+                        "type": "primitive",
+                        "alias": "undefined",
+                        "subType": "undefined"
+                    },
+                    {
+                        "type": "primitive",
+                        "alias": "null",
+                        "subType": "null"
+                    },
+                    {
+                        "type": "reference",
+                        "alias": "\"*\""
+                    },
+                    {
+                        "type": "primitive",
+                        "alias": "PublishFullyTyped<S>",
+                        "aliasSymbolescapedName": "PublishFullyTyped",
+                        "subType": "any"
+                    },
+                    {
+                        "type": "reference",
+                        "alias": "(params: PublishParams<S, SUser>) => Awaitable<PublishedResult<S>>"
+                    },
+                    {
+                        "type": "primitive",
+                        "alias": "false",
+                        "subType": "boolean"
+                    }
+                ],
+                "optional": true,
+                "comments": "Data access rules applied to clients.\nBy default, nothing is allowed."
+            },
+            "testRulesOnConnect": {
+                "type": "reference",
+                "alias": "boolean | undefined",
+                "comments": "If true then will test all table methods on each socket connect.\nNot recommended for production",
+                "optional": true
+            },
+            "publishMethods": {
+                "type": "reference",
+                "alias": "PublishMethods<S, SUser>",
+                "aliasSymbolescapedName": "PublishMethods",
+                "comments": "Custom methods that can be called from the client",
+                "optional": true
+            },
+            "publishRawSQL": {
+                "type": "reference",
+                "alias": "(params: PublishParams<S, SUser>) => boolean | \"*\" | Promise<boolean | \"*\">",
+                "comments": "If defined and resolves to true then the connected client can run SQL queries",
+                "optional": true
+            },
+            "joins": {
+                "type": "union",
+                "alias": "Joins | undefined",
+                "types": [
+                    {
+                        "type": "primitive",
+                        "alias": "undefined",
+                        "subType": "undefined"
+                    },
+                    {
+                        "type": "reference",
+                        "alias": "Join[]"
+                    },
+                    {
+                        "type": "reference",
+                        "alias": "\"inferred\""
+                    }
+                ],
+                "optional": true,
+                "comments": "Allows defining joins between tables:\n - `infered` - uses the foreign keys to infer the joins\n - `Join[]` - specifies the joins manually"
+            },
+            "schema": {
+                "type": "union",
+                "alias": "Record<string, 1> | Record<string, 0> | undefined",
+                "types": [
+                    {
+                        "type": "primitive",
+                        "alias": "undefined",
+                        "subType": "undefined"
+                    },
+                    {
+                        "type": "reference",
+                        "alias": "Record<string, 1>",
+                        "aliasSymbolescapedName": "Record",
+                        "comments": "Construct a type with a set of properties K of type T"
+                    },
+                    {
+                        "type": "reference",
+                        "alias": "Record<string, 0>",
+                        "aliasSymbolescapedName": "Record",
+                        "comments": "Construct a type with a set of properties K of type T"
+                    }
+                ],
+                "optional": true,
+                "comments": "If defined then the specified schemas are included/excluded from the prostgles schema.\nBy default the `public` schema is included."
+            },
+            "sqlFilePath": {
+                "type": "reference",
+                "alias": "string | undefined",
+                "comments": "Path to a SQL file that will be executed on startup (but before onReady)",
+                "optional": true
+            },
+            "transactions": {
+                "type": "union",
+                "alias": "string | boolean | undefined",
+                "types": [
+                    {
+                        "type": "primitive",
+                        "alias": "undefined",
+                        "subType": "undefined"
+                    },
+                    {
+                        "type": "primitive",
+                        "alias": "string",
+                        "subType": "string"
+                    },
+                    {
+                        "type": "primitive",
+                        "alias": "false",
+                        "subType": "boolean"
+                    }
+                ],
+                "optional": true
+            },
+            "wsChannelNamePrefix": {
+                "type": "reference",
+                "alias": "string | undefined",
+                "optional": true
+            },
+            "onSocketConnect": {
+                "type": "reference",
+                "alias": "(args: AuthRequestParams<S, SUser> & { socket: PRGLIOSocket; }) => void | Promise<void>",
+                "comments": "Called when a socket connects\nUse for connection verification. Will disconnect socket on any errors",
+                "optional": true
+            },
+            "onSocketDisconnect": {
+                "type": "reference",
+                "alias": "(args: AuthRequestParams<S, SUser> & { socket: PRGLIOSocket; }) => void | Promise<void>",
+                "comments": "Called when a socket disconnects",
+                "optional": true
+            },
+            "auth": {
+                "type": "reference",
+                "alias": "Auth<S, SUser>",
+                "aliasSymbolescapedName": "Auth",
+                "comments": "Auth configuration.\nSupports email and OAuth strategies",
+                "optional": true
+            },
+            "DEBUG_MODE": {
+                "type": "reference",
+                "alias": "boolean | undefined",
+                "optional": true
+            },
+            "onQuery": {
+                "type": "reference",
+                "alias": "(error: any, ctx: IEventContext<IClient>) => void",
+                "comments": "Callback called when a query is executed.\nUseful for logging or debugging",
+                "optional": true
+            },
+            "watchSchemaType": {
+                "type": "union",
+                "alias": "\"DDL_trigger\" | \"prostgles_queries\" | undefined",
+                "types": [
+                    {
+                        "type": "primitive",
+                        "alias": "undefined",
+                        "subType": "undefined"
+                    },
+                    {
+                        "type": "reference",
+                        "alias": "\"DDL_trigger\""
+                    },
+                    {
+                        "type": "reference",
+                        "alias": "\"prostgles_queries\""
+                    }
+                ],
+                "optional": true
+            },
+            "watchSchema": {
+                "type": "union",
+                "alias": "boolean | EventTriggerTagFilter | \"hotReloadMode\" | OnSchemaChangeCallback | undefined",
+                "types": [
+                    {
+                        "type": "primitive",
+                        "alias": "undefined",
+                        "subType": "undefined"
+                    },
+                    {
+                        "type": "reference",
+                        "alias": "\"*\""
+                    },
+                    {
+                        "type": "reference",
+                        "alias": "Partial<Record<\"ALTER AGGREGATE\" | \"ALTER COLLATION\" | \"ALTER CONVERSION\" | \"ALTER DOMAIN\" | \"ALTER DEFAULT PRIVILEGES\" | \"ALTER EXTENSION\" | \"ALTER FOREIGN DATA WRAPPER\" | \"ALTER FOREIGN TABLE\" | ... 102 more ... | \"SELECT INTO\", 1>>",
+                        "aliasSymbolescapedName": "Partial",
+                        "comments": "Make all properties in T optional"
+                    },
+                    {
+                        "type": "reference",
+                        "alias": "Partial<Record<\"ALTER AGGREGATE\" | \"ALTER COLLATION\" | \"ALTER CONVERSION\" | \"ALTER DOMAIN\" | \"ALTER DEFAULT PRIVILEGES\" | \"ALTER EXTENSION\" | \"ALTER FOREIGN DATA WRAPPER\" | \"ALTER FOREIGN TABLE\" | ... 102 more ... | \"SELECT INTO\", 0>>",
+                        "aliasSymbolescapedName": "Partial",
+                        "comments": "Make all properties in T optional"
+                    },
+                    {
+                        "type": "reference",
+                        "alias": "\"hotReloadMode\""
+                    },
+                    {
+                        "type": "reference",
+                        "alias": "OnSchemaChangeCallback",
+                        "aliasSymbolescapedName": "OnSchemaChangeCallback"
+                    },
+                    {
+                        "type": "primitive",
+                        "alias": "false",
+                        "subType": "boolean"
+                    }
+                ],
+                "optional": true,
+                "comments": "If truthy then DBSchemaGenerated.d.ts will be updated\nand \"onReady\" will be called with new schema on both client and server"
+            },
+            "keywords": {
+                "type": "reference",
+                "alias": "Keywords",
+                "aliasSymbolescapedName": "Keywords",
+                "optional": true
+            },
+            "onNotice": {
+                "type": "reference",
+                "alias": "(notice: AnyObject, message?: string | undefined) => void",
+                "optional": true
+            },
+            "fileTable": {
+                "type": "reference",
+                "alias": "FileTableConfig",
+                "aliasSymbolescapedName": "FileTableConfig",
+                "comments": "Enables file storage and serving.\nCurrently supports saving files locally or to AWS S3",
+                "optional": true
+            },
+            "restApi": {
+                "type": "reference",
+                "alias": "RestApiConfig",
+                "aliasSymbolescapedName": "RestApiConfig",
+                "comments": "Rest API configuration.\nThe REST API allows interacting with the database similarly to the socket connection\nwith the exception of subscriptions and realtime features",
+                "optional": true
+            },
+            "tableConfig": {
+                "type": "reference",
+                "alias": "TableConfig",
+                "aliasSymbolescapedName": "TableConfig",
+                "comments": "A simple way of defining tables through a JSON-schema like object.\nAllowes adding runtime JSONB validation and type safety.\nShould be used with caution because it tends to revert any changes\nmade to the database schema through SQL queries",
+                "optional": true
+            },
+            "tableConfigMigrations": {
+                "type": "reference",
+                "alias": "{ silentFail?: boolean | undefined; version: number; versionTableName?: string | undefined; onMigrate: (args: { db: DB; oldVersion: number | undefined; getConstraints: (table: string, column?: string | undefined, types?: (\"c\" | ... 2 more ... | \"f\")[] | undefined) => Promise<...>; }) => void; }",
+                "optional": true
+            },
+            "onLog": {
+                "type": "reference",
+                "alias": "(evt: EventInfo) => Promise<void>",
+                "comments": "Usefull for logging or debugging",
+                "optional": true
+            }
+        }
+    }
+];