prostgles-server 4.2.180 → 4.2.182

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

@@ -1,3 +1,2 @@
 export declare const generateClientDocs: () => void;
-export declare const generateMDX: (filePath: string) => void;
 //# sourceMappingURL=generateClientDocs.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"generateClientDocs.d.ts","sourceRoot":"","sources":["../generateClientDocs.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,kBAAkB,YAkD9B,CAAC;AAOF,eAAO,MAAM,WAAW,aAAc,MAAM,SA4B3C,CAAC"}
+{"version":3,"file":"generateClientDocs.d.ts","sourceRoot":"","sources":["../generateClientDocs.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,kBAAkB,YA0F9B,CAAC"}

package/documentation/utils/dist/generateClientDocs.js

@@ -1,19 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateMDX = exports.generateClientDocs = void 0;
+exports.generateClientDocs = void 0;
 const fs = require("fs");
 const path = require("path");
 const prostgles_types_1 = require("prostgles-types");
-const getResolvedTypes_1 = require("./getResolvedTypes");
-const prostgles_types_2 = require("prostgles-types");
 const clientTypes_1 = require("./clientTypes");
+const getResolvedTypes_1 = require("./getResolvedTypes");
 const testFolderPath = `${__dirname}/../../../tests/`;
 const docsFolder = `${__dirname}/../../`;
 const generateClientDocs = () => {
     const clientFilePath = path.resolve(`${testFolderPath}/client/node_modules/prostgles-client/dist/prostgles.d.ts`);
     const excludedTypes = [
-        "FullFilter",
-        "FullFilter<T, S> | undefined",
+        // "FullFilter",
+        // "FullFilter<T, S> | undefined",
         "FieldFilter | undefined",
         "SyncOptions",
         "SyncOneOptions",
@@ -22,17 +21,14 @@ const generateClientDocs = () => {
     const { resolvedTypes, visitedMaps } = (0, getResolvedTypes_1.getResolvedTypes)({
         filePath: clientFilePath,
         filter: {
-            nodeNames: [
-                // "ViewHandlerClient",
-                "TableHandlerClient",
-            ],
+            nodeNames: ["TableHandlerClient"],
             excludedTypes,
         },
     });
     const jsonTypes = JSON.stringify([
         ...resolvedTypes,
         ...visitedMaps
-            .flatMap((m) => Array.from(m.values()).map((v) => { var _a; return excludedTypes.includes((_a = v.resolvedType.alias) !== null && _a !== void 0 ? _a : "") ? v.resolvedType : undefined; }))
+            .flatMap((m) => Array.from(m.values()).map((v) => excludedTypes.includes(v.resolvedType.alias ?? "") ? v.resolvedType : undefined))
             .filter(prostgles_types_1.isDefined),
     ], null, 2);
     fs.writeFileSync(`${__dirname}/../clientTypes.ts`, [
@@ -41,8 +37,38 @@ const generateClientDocs = () => {
     ].join("\n"), {
         encoding: "utf-8",
     });
-    const docPath = `${docsFolder}CLIENT.md`;
-    (0, exports.generateMDX)(docPath);
+    const docPath = `${docsFolder}METHODS.md`;
+    const tableHandler = clientTypes_1.definitions[0];
+    const isomotphicMethodNames = {
+        count: 1,
+        delete: 1,
+        find: 1,
+        insert: 1,
+        update: 1,
+        findOne: 1,
+        getColumns: 1,
+        getInfo: 1,
+        size: 1,
+        subscribe: 1,
+        subscribeOne: 1,
+        updateBatch: 1,
+        upsert: 1,
+    };
+    const isomorphicMd = getMethodsDocs((0, prostgles_types_1.getObjectEntries)(tableHandler.properties).filter(([methodName]) => isomotphicMethodNames[methodName]));
+    const clientMd = getMethodsDocs((0, prostgles_types_1.getObjectEntries)(tableHandler.properties).filter(([methodName]) => !isomotphicMethodNames[methodName]));
+    const result = [
+        `# Isomorphic Methods`,
+        ``,
+        `The following methods are available on the client and server.`,
+        ``,
+        isomorphicMd.join("\n\n"),
+        `# Client Methods`,
+        ``,
+        `The following methods are available on the client.`,
+        ``,
+        clientMd.join("\n\n"),
+    ].join("\n");
+    fs.writeFileSync(docPath, result, { encoding: "utf-8" });
 };
 exports.generateClientDocs = generateClientDocs;
 const getAliasWithoutGenerics = (type) => {
@@ -50,47 +76,64 @@ const getAliasWithoutGenerics = (type) => {
         return type.types.map(getAliasWithoutGenerics).join(" | ");
     return type.aliasSymbolescapedName || type.alias;
 };
-const generateMDX = (filePath) => {
-    const tableHandler = clientTypes_1.definitions[0];
-    const mdxContent = (0, prostgles_types_2.getObjectEntries)(tableHandler.properties).map(([methodName, _methodInfo]) => {
-        var _a;
+const getMethodsDocs = (methods) => {
+    return methods.map(([methodName, _methodInfo]) => {
         const methodInfo = (_methodInfo.type === "function" ?
             _methodInfo
             // : _methodInfo.type === "union" ? _methodInfo.types.find((t) => t.type === "function")
             : undefined);
         if (!methodInfo)
             return "";
+        const args = `${methodInfo.arguments
+            .map((arg) => `${arg.name}${arg.optional ? "?" : ""}: ${getAliasWithoutGenerics(arg)}`)
+            .join(", ")}`;
+        const rType = `${methodInfo.returnType.aliasSymbolescapedName || methodInfo.returnType.alias}`
+            .replaceAll("<", "&lt;")
+            .replaceAll(">", "&gt;");
         return [
-            `## ${methodName}()`,
-            (_a = methodInfo.comments) !== null && _a !== void 0 ? _a : "",
-            `\`\`\`typescript
-  ${methodName}: (${methodInfo.arguments
-                .map((arg) => `${arg.name}${arg.optional ? "?" : ""}: ${getAliasWithoutGenerics(arg)}`)
-                .join(", ")}): ${methodInfo.returnType.aliasSymbolescapedName || methodInfo.returnType.alias}
-  \`\`\``,
-            `#### Arguments`,
+            `## ${methodName}<span style="opacity: 0.6;">(${args}): ${rType}</span>`,
+            methodInfo.comments ?? "",
+            `\`\`\`typescript`,
+            `${methodName}: (): `,
+            `\`\`\``,
+            `#### Parameters`,
             ``,
             ...methodInfo.arguments.map((arg) => {
                 return renderType(arg, 2, { name: arg.name, optional: arg.optional });
             }),
-            `#### Return type`,
-            renderType(methodInfo.returnType, 0, undefined),
+            // `#### Return type`,
+            `#### ` + renderType(methodInfo.returnType, 0, undefined),
         ].join("\n");
     });
-    const result = mdxContent.join("\n\n");
-    fs.writeFileSync(filePath, result, { encoding: "utf-8" });
 };
-exports.generateMDX = generateMDX;
+const renderedAliases = new Set();
 const renderType = (type, indent = 2, argOrProp) => {
     const indentText = " ".repeat(indent);
-    const title = `${indentText}${(argOrProp === null || argOrProp === void 0 ? void 0 : argOrProp.name) ? `- **${argOrProp.name}**: ` : ""}\`${type.aliasSymbolescapedName || type.alias}\`  ${type.comments ? ` - ${removeLineBreaks(type.comments)}` : ""}`;
+    const typeAlias = `\`${type.aliasSymbolescapedName || type.alias}\``;
+    const typeText = type.aliasSymbolescapedName && type.type === "object" ?
+        `<span style="color: green;">${type.aliasSymbolescapedName}</span>`
+        : typeAlias;
+    const title = [
+        `${indentText}${argOrProp?.name ? `- **${argOrProp.name}**: ` : ""}${typeAlias}`,
+        `${type.comments ? `${removeLineBreaks(type.comments, indentText + "  ")}` : ""}`,
+    ].join("\n\n");
+    if (typeAlias?.includes("FullFilter")) {
+        // debugger;
+    }
+    /**
+     * Re-use rendered types by linking them through an anchor tag
+     */
+    if (type.aliasSymbolescapedName && argOrProp?.name) {
+        renderedAliases.add(type.aliasSymbolescapedName);
+        console.log(type.aliasSymbolescapedName);
+    }
     if (type.type === "primitive" || type.type === "literal") {
         return title;
     }
     if (type.type === "object") {
         return (title +
             `\n` +
-            (0, prostgles_types_2.getObjectEntries)(type.properties)
+            (0, prostgles_types_1.getObjectEntries)(type.properties)
                 .map(([name, p]) => renderType(p, indent + 2, { name, optional: p.optional }))
                 .join("\n"));
     }
@@ -106,10 +149,17 @@ const renderType = (type, indent = 2, argOrProp) => {
     }
     return title;
 };
-const removeLineBreaks = (str = "") => str
+const removeLineBreaks = (str, indent) => str
     .split("\n")
     .map((line) => {
-    if (!line.trim().endsWith("."))
-        return `${line}.`;
+    return `${indent}${line.trimStart()}`;
 })
-    .join(" ");
+    .join("\n");
+const renderTypeAlias = (type) => {
+    const typeAlias = type.aliasSymbolescapedName || type.alias;
+    const style = type.aliasSymbolescapedName ? `style="color: green;"` : "";
+    // if (renderedAliases.has(typeAlias)) {
+    //   return `<a ${style} href="#${typeAlias}">${typeAlias}</a>`;
+    // }
+    return `<span ${style}>${typeAlias}</span>`;
+};

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

@@ -1 +1 @@
-{"version":3,"file":"generateServerDocs.d.ts","sourceRoot":"","sources":["../generateServerDocs.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,kBAAkB,YAuE9B,CAAC"}
+{"version":3,"file":"generateServerDocs.d.ts","sourceRoot":"","sources":["../generateServerDocs.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,kBAAkB,YAyE9B,CAAC"}

package/documentation/utils/dist/generateServerDocs.js

@@ -13,7 +13,7 @@ const generateServerDocs = () => {
     // `${testFolderPath}/server/node_modules/prostgles-server/dist/DBSchemaBuilder.d.ts` // "DBOFullyTyped",
     `${testFolderPath}/server/node_modules/prostgles-server/dist/ProstglesTypes.d.ts` // "ProstglesInitOptions",
     );
-    const { resolvedTypes: [ProstglesInitOptions], visitedMaps, } = (0, getResolvedTypes_1.getResolvedTypes)({
+    const { resolvedTypes: [ProstglesInitOptions], } = (0, getResolvedTypes_1.getResolvedTypes)({
         filePath: serverFilePath,
         filter: {
             nodeNames: [
@@ -24,9 +24,14 @@ const generateServerDocs = () => {
             maxDepth: 2,
         },
     });
-    if (!ProstglesInitOptions)
-        throw new Error("ProstglesInitOptions not found");
+    const serverTypesStr = [
+        `import type { TS_Type } from "./getSerializableType";`,
+        `export const definitions = ${JSON.stringify([ProstglesInitOptions], null, 2)} as const satisfies TS_Type[];`,
+    ].join("\n");
+    fs.writeFileSync(`${docsFolder}/utils/serverTypes.ts`, serverTypesStr, { encoding: "utf-8" });
     const prostglesInitOpts = serverTypes_1.definitions[0];
+    if (!ProstglesInitOptions || !prostglesInitOpts)
+        throw new Error("ProstglesInitOptions not found");
     const docs = [
         `# Overview`,
         `Our Isomorphic Typescript API allows connecting to a PostgreSQL database to get a realtime view of the data and schema. Interact with the data with full end-to-end type safety.`,
@@ -41,8 +46,8 @@ const generateServerDocs = () => {
         `Basic example:`,
         `\`\`\`typescript`,
         `import prostgles from "prostgles-server";`,
-        `import { DBSchemaGenerated } from "./DBSchemaGenerated";`,
-        `prostgles<DBSchemaGenerated>({`,
+        `import { DBGeneratedSchema } from "./DBGeneratedSchema";`,
+        `prostgles<DBGeneratedSchema>({`,
         `  dbConnection: {`,
         `    host: "localhost",`,
         `    port: 5432,`,
@@ -63,6 +68,7 @@ const generateServerDocs = () => {
         `\`\`\``,
         `### Configuration options`,
         ...(0, prostgles_types_1.getObjectEntries)(prostglesInitOpts.properties).map(([propName, prop]) => {
+            //@ts-ignore
             const title = `  - <strong>${propName}</strong> \`${prop.aliasSymbolescapedName || prop.alias}\``;
             const comments = prop.comments || "";
             if (!comments)
@@ -70,11 +76,6 @@ const generateServerDocs = () => {
             return [title, `  ` + comments + "  "].join("\n");
         }),
     ].join("\n");
-    const serverTypesStr = [
-        `import type { TS_Type } from "./getSerializableType";`,
-        `export const definitions = ${JSON.stringify([ProstglesInitOptions], null, 2)} as const satisfies TS_Type[];`,
-    ].join("\n");
-    fs.writeFileSync(`${docsFolder}/utils/serverTypes.ts`, serverTypesStr, { encoding: "utf-8" });
     fs.writeFileSync(`${docsFolder}SERVER.md`, docs, { encoding: "utf-8" });
 };
 exports.generateServerDocs = generateServerDocs;

package/documentation/utils/dist/getResolvedTypes.js

@@ -14,7 +14,7 @@ const getResolvedTypes = ({ filePath, filter }) => {
         //   console.log("node.name.text", node.getText());
         // }
         if (ts.isTypeAliasDeclaration(node)) {
-            if (!filter || (filter === null || filter === void 0 ? void 0 : filter.nodeNames.includes(node.name.text))) {
+            if (!filter || filter?.nodeNames.includes(node.name.text)) {
                 const type1 = checker.getTypeAtLocation(node.type);
                 const { resolvedType, visited } = (0, getSerializableType_1.getSerializableType)(type1, checker, undefined, [], filter, 0);
                 results.push(resolvedType);

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

@@ -2,8 +2,8 @@ import * as ts from "typescript";
 type TS_Base = {
     alias?: string;
     aliasSymbolescapedName?: string;
-    intersectionParent?: string;
     comments?: string;
+    intersectionParent?: string;
 };
 export type TS_Literal = TS_Base & {
     type: "literal";

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

@@ -1 +1 @@
-{"version":3,"file":"getSerializableType.d.ts","sourceRoot":"","sources":["../getSerializableType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAGjC,KAAK,OAAO,GAAG;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG;IACjC,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG;IACnC,IAAI,EAAE,WAAW,CAAC;IAClB,OAAO,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,KAAK,GAAG,MAAM,GAAG,WAAW,CAAC;CACzE,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG;IAChC,IAAI,EAAE,QAAQ,CAAC;IACf,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG;QAAE,QAAQ,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CAC7D,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG;IAC/B,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG;IAC/B,IAAI,EAAE,OAAO,CAAC;IACd,SAAS,EAAE,OAAO,EAAE,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG;IAClC,IAAI,EAAE,UAAU,CAAC;IACjB,SAAS,EAAE,CAAC,OAAO,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,CAAC,EAAE,CAAC;IAC7D,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG;IACjC,IAAI,EAAE,SAAS,CAAC;IAChB,SAAS,EAAE,OAAO,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;CACzC,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG;IAC/B,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,OAAO,EAAE,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG;IACnC,IAAI,EAAE,WAAW,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,OAAO,GACf,YAAY,GACZ,UAAU,GACV,SAAS,GACT,QAAQ,GACR,QAAQ,GACR,WAAW,GACX,QAAQ,GACR,UAAU,GACV,YAAY,CAAC;AAEjB,MAAM,MAAM,eAAe,GAAG,GAAG,CAC/B,MAAM,EACN;IAAE,YAAY,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC;IAAC,aAAa,CAAC,EAAE,OAAO,CAAA;CAAE,CAClE,CAAC;AAEF,eAAO,MAAM,mBAAmB,WACtB,GAAG,IAAI,WACN,GAAG,WAAW,uDAER,MAAM,EAAE,QACjB,kBAAkB,GAAG,SAAS,SAC7B,MAAM;kBACI,OAAO;;CAoUzB,CAAC;AAEF,KAAK,kBAAkB,GAAG;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AACF,eAAO,MAAM,WAAW,WACd,GAAG,IAAI,WACN,GAAG,WAAW,QACjB,kBAAkB;kBACP,OAAO;;CAMzB,CAAC"}
+{"version":3,"file":"getSerializableType.d.ts","sourceRoot":"","sources":["../getSerializableType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAGjC,KAAK,OAAO,GAAG;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG;IACjC,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG;IACnC,IAAI,EAAE,WAAW,CAAC;IAClB,OAAO,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,KAAK,GAAG,MAAM,GAAG,WAAW,CAAC;CACzE,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG;IAChC,IAAI,EAAE,QAAQ,CAAC;IACf,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG;QAAE,QAAQ,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CAC7D,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG;IAC/B,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG;IAC/B,IAAI,EAAE,OAAO,CAAC;IACd,SAAS,EAAE,OAAO,EAAE,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG;IAClC,IAAI,EAAE,UAAU,CAAC;IACjB,SAAS,EAAE,CAAC,OAAO,GAAG;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,CAAC,EAAE,CAAC;IAC7D,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG;IACjC,IAAI,EAAE,SAAS,CAAC;IAChB,SAAS,EAAE,OAAO,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;CACzC,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG;IAC/B,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,OAAO,EAAE,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG;IACnC,IAAI,EAAE,WAAW,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,OAAO,GACf,YAAY,GACZ,UAAU,GACV,SAAS,GACT,QAAQ,GACR,QAAQ,GACR,WAAW,GACX,QAAQ,GACR,UAAU,GACV,YAAY,CAAC;AAEjB,MAAM,MAAM,eAAe,GAAG,GAAG,CAC/B,MAAM,EACN;IAAE,YAAY,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC;IAAC,aAAa,CAAC,EAAE,OAAO,CAAA;CAAE,CAClE,CAAC;AAEF,eAAO,MAAM,mBAAmB,WACtB,GAAG,IAAI,WACN,GAAG,WAAW,uDAER,MAAM,EAAE,QACjB,kBAAkB,GAAG,SAAS,SAC7B,MAAM;kBACI,OAAO;;CA8UzB,CAAC;AAEF,KAAK,kBAAkB,GAAG;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AACF,eAAO,MAAM,WAAW,WACd,GAAG,IAAI,WACN,GAAG,WAAW,QACjB,kBAAkB;kBACP,OAAO;;CAMzB,CAAC"}

package/documentation/utils/dist/getSerializableType.js

@@ -4,11 +4,10 @@ exports.resolveType = exports.getSerializableType = void 0;
 const ts = require("typescript");
 const prostgles_types_1 = require("prostgles-types");
 const getSerializableType = (myType, checker, visited = new Map(), parentAliases, opts, depth) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
     let alias = "unknown";
-    const { escapedName } = (_a = myType.aliasSymbol) !== null && _a !== void 0 ? _a : {};
-    const aliasSymbolescapedName = escapedName === null || escapedName === void 0 ? void 0 : escapedName.toString();
-    const symbol = (_b = myType.aliasSymbol) !== null && _b !== void 0 ? _b : myType.symbol;
+    const { escapedName } = myType.aliasSymbol ?? {};
+    const aliasSymbolescapedName = escapedName?.toString();
+    const symbol = myType.aliasSymbol ?? myType.symbol;
     const comments = symbol ? getSymbolComments(symbol, checker) : undefined;
     try {
         alias = checker.typeToString(myType);
@@ -19,21 +18,20 @@ const getSerializableType = (myType, checker, visited = new Map(), parentAliases
     /* Circular resolved type */
     const visitedType = visited.get(alias);
     if (visitedType) {
-        return { resolvedType: (_c = visitedType.referenceType) !== null && _c !== void 0 ? _c : visitedType.resolvedType, visited };
+        return { resolvedType: visitedType.referenceType ?? visitedType.resolvedType, visited };
     }
     const withAlias = (_type) => {
-        var _a;
         const finalComments = _type.comments || comments;
         const resolvedType = sortObjectsByKeyOrder({
-            alias: (_a = _type.alias) !== null && _a !== void 0 ? _a : alias,
+            alias: _type.alias ?? alias,
             aliasSymbolescapedName,
             ..._type,
             ...(finalComments && { comments: finalComments }),
         }, ["type", "alias", "aliasSymbolescapedName", "comments"]);
         let referenceType;
-        if ((opts === null || opts === void 0 ? void 0 : opts.excludedTypes.includes(alias)) ||
-            (escapedName && (opts === null || opts === void 0 ? void 0 : opts.excludedTypes.includes(escapedName))) ||
-            ((opts === null || opts === void 0 ? void 0 : opts.maxDepth) !== undefined && depth >= opts.maxDepth)) {
+        if (opts?.excludedTypes.includes(alias) ||
+            (escapedName && opts?.excludedTypes.includes(escapedName)) ||
+            (opts?.maxDepth !== undefined && depth >= opts.maxDepth)) {
             referenceType =
                 resolvedType.type === "primitive" ?
                     resolvedType
@@ -45,9 +43,9 @@ const getSerializableType = (myType, checker, visited = new Map(), parentAliases
                     };
         }
         visited.set(alias, { resolvedType, referenceType, type: myType });
-        return { resolvedType: referenceType !== null && referenceType !== void 0 ? referenceType : resolvedType, visited };
+        return { resolvedType: referenceType ?? resolvedType, visited };
     };
-    const unresolvedParentAliases = (_d = parentAliases === null || parentAliases === void 0 ? void 0 : parentAliases.filter((a) => !visited.get(a))) !== null && _d !== void 0 ? _d : [];
+    const unresolvedParentAliases = parentAliases?.filter((a) => !visited.get(a)) ?? [];
     /* Circular unresolved type */
     if (unresolvedParentAliases.includes(alias)) {
         return withAlias({
@@ -99,9 +97,9 @@ const getSerializableType = (myType, checker, visited = new Map(), parentAliases
     if (checker.isArrayType(myType)) {
         const itemType = checker.getTypeArguments(myType)[0];
         if (itemType && checker.isTupleType(itemType)) {
-            const tupleTypes = (_e = itemType.resolvedTypeArguments.map((d) => {
+            const tupleTypes = itemType.resolvedTypeArguments.map((d) => {
                 return (0, exports.getSerializableType)(d, checker, visited, nextUnresolvedParentAliases, opts, depth + 1).resolvedType;
-            })) !== null && _e !== void 0 ? _e : [];
+            }) ?? [];
             return withAlias({
                 type: "tuple",
                 itemTypes: tupleTypes,
@@ -149,12 +147,12 @@ const getSerializableType = (myType, checker, visited = new Map(), parentAliases
         if (objectType.objectFlags & ts.ObjectFlags.Reference) {
             const typeReference = objectType;
             const target = typeReference.target;
-            if (((_f = target.symbol) === null || _f === void 0 ? void 0 : _f.escapedName) === "Promise") {
+            if (target.symbol?.escapedName === "Promise") {
                 const _innerType = checker.getTypeArguments(typeReference)[0];
                 const defaultType = { type: "primitive", subType: "any" };
                 const resolvedInnerType = _innerType &&
                     (0, exports.getSerializableType)(_innerType, checker, visited, nextUnresolvedParentAliases, opts, depth + 1).resolvedType;
-                const innerType = (resolvedInnerType === null || resolvedInnerType === void 0 ? void 0 : resolvedInnerType.type) === "promise" ? defaultType : (resolvedInnerType !== null && resolvedInnerType !== void 0 ? resolvedInnerType : defaultType);
+                const innerType = resolvedInnerType?.type === "promise" ? defaultType : (resolvedInnerType ?? defaultType);
                 return withAlias({
                     type: "promise",
                     innerType,
@@ -173,8 +171,11 @@ const getSerializableType = (myType, checker, visited = new Map(), parentAliases
                 comments: propertyComments || undefined,
             };
         });
-        const comments = ((_g = myType.aliasSymbol) === null || _g === void 0 ? void 0 : _g.declarations) &&
-            ((_j = getNonInternalTSDeclarations((_h = myType.aliasSymbol) === null || _h === void 0 ? void 0 : _h.declarations)) === null || _j === void 0 ? void 0 : _j.flatMap((d) => (!d.jsDoc ? [] : d.jsDoc.map((jd) => jd.comment))).join("\n"));
+        const comments = myType.aliasSymbol?.declarations &&
+            getNonInternalTSDeclarations(myType.aliasSymbol?.declarations)
+                //@ts-ignore
+                ?.flatMap((d) => (!d.jsDoc ? [] : d.jsDoc.map((jd) => jd.comment)))
+                .join("\n");
         return withAlias({
             type: "object",
             properties,
@@ -187,12 +188,18 @@ const getSerializableType = (myType, checker, visited = new Map(), parentAliases
     if (myType.isIntersection()) {
         const intersectionTypes = myType.types.map((t) => {
             const { resolvedType: intersectionType } = (0, exports.getSerializableType)(t, checker, visited, nextUnresolvedParentAliases, opts, depth + 1);
-            intersectionType.intersectionParent = aliasSymbolescapedName || alias;
+            if (intersectionType.type === "object") {
+                intersectionType.intersectionParent = aliasSymbolescapedName;
+            }
             return intersectionType;
         });
         if (intersectionTypes.every((t) => t.type === "object")) {
             const properties = intersectionTypes.reduce((acc, t) => {
-                return { ...acc, ...t.properties };
+                const propertiesWithParentObject = Object.entries(t.properties).reduce((acc, [k, v]) => ({
+                    ...acc,
+                    [k]: { ...v, intersectionParent: t.aliasSymbolescapedName },
+                }), {});
+                return { ...acc, ...propertiesWithParentObject };
             }, {});
             return withAlias({
                 type: "object",
@@ -244,9 +251,8 @@ const sortObjectsByKeyOrder = (obj, keyOrder) => {
 const arraySort = (arrayToSort, keyOrder) => {
     const keyOrderMap = new Map(keyOrder.map((value, index) => [value, index]));
     return arrayToSort.sort((a, b) => {
-        var _a, _b;
-        const aIndex = (_a = keyOrderMap.get(a)) !== null && _a !== void 0 ? _a : Infinity;
-        const bIndex = (_b = keyOrderMap.get(b)) !== null && _b !== void 0 ? _b : Infinity;
+        const aIndex = keyOrderMap.get(a) ?? Infinity;
+        const bIndex = keyOrderMap.get(b) ?? Infinity;
         return aIndex - bIndex;
     });
 };

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

@@ -1 +1 @@
-{"version":3,"file":"loadTsFile.d.ts","sourceRoot":"","sources":["../loadTsFile.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,eAAO,MAAM,UAAU,aAAc,MAAM;;;;CAyC1C,CAAC"}
+{"version":3,"file":"loadTsFile.d.ts","sourceRoot":"","sources":["../loadTsFile.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,eAAO,MAAM,UAAU,aAAc,MAAM;;;;CAqC1C,CAAC"}

package/documentation/utils/dist/loadTsFile.js

@@ -4,17 +4,13 @@ exports.loadTsFile = void 0;
 const path = require("path");
 const ts = require("typescript");
 const loadTsFile = (filePath) => {
-    // Normalize file path
     const absolutePath = path.resolve(filePath);
-    // Create compiler host and program
     const configPath = ts.findConfigFile(path.dirname(absolutePath), ts.sys.fileExists, "tsconfig.json");
     if (!configPath) {
         throw new Error("Could not find a valid 'tsconfig.json'.");
     }
-    // Parse the config file
     const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
     const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(configPath));
-    // Create program
     const program = ts.createProgram({
         rootNames: [absolutePath],
         options: parsedConfig.options,

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

@@ -39,15 +39,10 @@ export declare const definitions: [{
             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 comments: "If defined then a `DBGeneratedSchema.d.ts` file will be created in the provided directory.\nThis file exports a `DBGeneratedSchema` 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: {
@@ -257,7 +252,7 @@ export declare const definitions: [{
                 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 comments: "If truthy then DBGeneratedSchema.d.ts will be updated\nand \"onReady\" will be called with new schema on both client and server";
         };
         readonly keywords: {
             readonly type: "reference";
@@ -272,8 +267,7 @@ export declare const definitions: [{
         };
         readonly fileTable: {
             readonly type: "reference";
-            readonly alias: "FileTableConfig";
-            readonly aliasSymbolescapedName: "FileTableConfig";
+            readonly alias: "FileTableConfig | undefined";
             readonly comments: "Enables file storage and serving.\nCurrently supports saving files locally or to AWS S3";
             readonly optional: true;
         };

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

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

package/documentation/utils/dist/serverTypes.js

@@ -48,15 +48,10 @@ exports.definitions = [
                 "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",
+                "comments": "If defined then a `DBGeneratedSchema.d.ts` file will be created in the provided directory.\nThis file exports a `DBGeneratedSchema` 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": {
@@ -297,7 +292,7 @@ exports.definitions = [
                     }
                 ],
                 "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"
+                "comments": "If truthy then DBGeneratedSchema.d.ts will be updated\nand \"onReady\" will be called with new schema on both client and server"
             },
             "keywords": {
                 "type": "reference",
@@ -312,8 +307,7 @@ exports.definitions = [
             },
             "fileTable": {
                 "type": "reference",
-                "alias": "FileTableConfig",
-                "aliasSymbolescapedName": "FileTableConfig",
+                "alias": "FileTableConfig | undefined",
                 "comments": "Enables file storage and serving.\nCurrently supports saving files locally or to AWS S3",
                 "optional": true
             },