prostgles-server 4.2.158 → 4.2.160

package/tests/server/package.json

@@ -1,25 +0,0 @@
-{
-  "name": "server_tests",
-  "version": "1.0.0",
-  "description": "",
-  "main": "index.js",
-  "scripts": {
-    "start": "tsc-watch --onSuccess \"node dist/server/index.js\"",
-    "dev": "NOSTOP=true npm start",
-    "build": "rm -rf ./node_modules/* && rm -rf ./media/* && rm -rf ./dist/* && npm i && tsc",
-    "test-server": "TEST_TYPE=server node --trace-uncaught --test dist/server/index.js ",
-    "test-client": "TEST_TYPE=client node --trace-uncaught --test dist/server/index.js "
-  },
-  "author": "",
-  "license": "ISC",
-  "dependencies": {
-    "express": "^4.21.1",
-    "prostgles-server": "file:../.."
-  },
-  "devDependencies": {
-    "@types/node": "^20.9.2",
-    "socket.io": "^4.8.1",
-    "tsc-watch": "^6.2.1",
-    "typescript": "^5.3.3"
-  }
-}

package/tests/server/publishTypeCheck.ts

@@ -1,136 +0,0 @@
-
-import { DBSchemaGenerated } from "./DBoGenerated";
-
-import { PublishFullyTyped } from "prostgles-server/dist/DBSchemaBuilder";
-export const testPublishTypes = () => {
-  (() => {
-    const p1: PublishFullyTyped<DBSchemaGenerated> = {
-      items: {
-        delete: "*",
-        select: {
-          fields: { h: 1, id: 1 },
-          forcedFilter: { $and: [
-            { h: { $overlaps: ["23", "32"]} },
-            { $existsJoined: { items: { "h.$eq": [] } } }
-          ]}
-        }
-      },
-      items3: "*"
-    }
-    const p2: PublishFullyTyped<DBSchemaGenerated> = "*"
-
-    const p11: PublishFullyTyped = {
-      items: {
-        delete: "*",
-        select: {
-          fields: { h: 1, id: 1 },
-          forcedFilter: { 
-            $and: [ 
-              { h: { $overlaps: ["23", "32"]} },
-              { $existsJoined: { items: { "h.$eq": [] } } }
-            ] 
-          }
-        }
-      },
-      items3: "*"
-    };
-    const p123: PublishFullyTyped<DBSchemaGenerated> = p11;
-    //@ts-ignore 
-    const p1234: PublishFullyTyped = p1;
-
-    const p12: PublishFullyTyped = "*";
-
-
-
-    const res: PublishFullyTyped =  {
-      shapes: "*",
-      items: "*",
-      items2: "*",
-      items3: "*",
-      v_items: "*",
-      various: "*",
-      tr1: "*",
-      tr2: "*",
-      tr3: "*",
-      planes: {
-        select: "*",
-        update: "*",
-        insert: "*",
-        delete: "*",
-        sync: {
-          id_fields: ["id"],
-          synced_field: "last_updated"
-        }
-      },
-
-      items4: {
-        select: Math.random()? "*" : {
-          fields: { name: 0 },
-          forcedFilter: { name: "abc" }
-        },
-        insert: "*",
-        update: "*",
-        delete: "*"
-      },
-
-      items4_pub: "*",
-      "*": {
-        select: { fields: { "*": 0 }},
-        insert: "*",
-        update: "*",
-      },
-      [`"*"`]: {
-        select: { fields: { [`"*"`]: 0 }},
-        insert: "*",
-        update: "*",
-      },
-      obj_table: "*",
-      media: "*", 
-      insert_rules: {
-        insert: {
-          fields: "*",
-          returningFields: { name: 1 },
-          validate: async ({ row }) => {
-            if(row.name === "a") row.name = "b"
-            return row
-          }
-        }
-      },
-      uuid_text: {
-        insert: {
-          fields: "*",
-          forcedData: {
-            id: 'c81089e1-c4c1-45d7-a73d-e2d613cb7c3e'
-          }
-        },
-        update: {
-          fields: [],
-          dynamicFields: [{
-            fields: { id: 1 },
-            filter: {
-              id: 'c81089e1-c4c1-45d7-a73d-e2d613cb7c3e'
-            }
-          }]
-        }
-      }
-    };
-
-    const res2: PublishFullyTyped<DBSchemaGenerated> = res; 
-    const res3: PublishFullyTyped<DBSchemaGenerated> = {
-      items: {
-        select: {
-          fields: {
-            h: 1
-          },
-          forcedFilter: {
-            // "h.$eq": ["2"]
-            $and: [
-              { "h.$eq": ["2"] }
-            ]
-          }
-        }
-      }
-    }; 
-
-  })
-}

package/tests/server/server.ts

@@ -1,35 +0,0 @@
-
-import path from 'path';
-import prostgles from "prostgles-server"; 
-import { DBSchemaGenerated } from "./DBoGenerated";
-
-prostgles<DBSchemaGenerated>({
-  dbConnection: {
-    connectionString: process.env.DB_CONNECTION
-  },
-  tsGeneratedTypesDir: path.join(__dirname + '/'),
-  tableConfig: {
-    user: {
-      columns: {
-        id: "SERIAL PRIMARY KEY",
-        email: "TEXT NOT NULL",
-        status: { enum: ["active", "disabled", "pending"] },
-        preferences: {
-          jsonbSchemaType: {
-            showIntro: { type: "boolean", optional: true },
-            theme: { enum: ["light", "dark", "auto"], optional: true },
-            two_factor_auth: { oneOf: [
-              { type: { enum: ["app"] } }
-            ] }
-          }
-        },
-      }
-    }
-  },
-  onReady: async (db) => {
-    const user = await db.users.findOne({ id: 123 });
-
-    
-    // user.preferences.theme = 
-  }
-});

package/tests/server/testPublish.ts

@@ -1,147 +0,0 @@
-
-import { Publish, PublishTableRule } from "prostgles-server/dist/PublishParser/PublishParser";
-import { DBSchemaGenerated } from "./DBoGenerated"; 
-import type { PublishFullyTyped } from "prostgles-server/dist/DBSchemaBuilder"; 
-
-export const testPublish: Publish<DBSchemaGenerated> = async ({ user, sid }) => {
-  if(sid === "noAuth"){
-    return {
-      planes: {
-        select: { fields: { last_updated: 0 } }
-      }
-    }
-  }
-  if(sid === "rest_api"){
-    return {
-      planes: "*"
-    }
-  }
-  const users_public_info =  {
-    select: {
-      fields: "*",
-      forcedFilter: { sid },
-    },
-    insert: {
-      fields: "*",
-      forcedData: { sid },
-    },
-    delete: {
-      filterFields: "*",
-      forcedFilter: { sid },
-    },
-    update: {
-      fields: "*",
-      forcedFilter: { sid },
-    },
-  } satisfies PublishTableRule<DBSchemaGenerated["users_public_info"]["columns"], DBSchemaGenerated>;
-
-  if(sid === "files"){
-    return {
-      users_public_info
-    }
-  }
-  const res: PublishFullyTyped<DBSchemaGenerated> =  {
-    shapes: "*",
-    items: "*",
-    items2: "*",
-    items3: "*",
-    items4a: "*",
-    tjson: "*", 
-    items_multi: "*", 
-    v_items: "*",
-    various: "*",
-    tr1: "*",
-    tr2: "*",
-    tr3: "*",
-    planes: {
-      select: sid === "client_only"? { fields: { last_updated: false } } : "*",
-      update: "*",
-      insert: "*",
-      delete: "*",
-      sync: {
-        id_fields: ["id"],
-        synced_field: "last_updated"
-      }
-    },
-
-    items4: {
-      select: user? "*" : {
-        fields: { name: 0 },
-        orderByFields: { added: 1 },
-        forcedFilter: { name: "abc" }
-      },
-      insert: "*",
-      update: "*",
-      delete: "*"
-    },
-
-    items4_pub: "*",
-    [`"*"`]: {
-      select: { fields: { "*": 0 }},
-      insert: "*",
-      update: "*",
-    },
-    [`"""*"""`]: {
-      select: { fields: { [`"*"`]: 0 }},
-      insert: "*",
-      update: "*",
-    },
-    obj_table: "*",
-    files: "*",
-    users_public_info,
-    self_join: "*",  
-    insert_rules: {
-      select: "*",
-      insert: {
-        fields: { added: 0 },
-        returningFields: { name: 1 },
-        validate: async ({ row }) => {
-          if(row.name === "a") row.name = "b";
-          row.added = (new Date()).toUTCString();
-          return row
-        },
-        checkFilter: {
-          $and: [{ "name.<>": "fail-check" }]
-        },
-        postValidate: async ({ row, dbx: dboTx}) => {
-          /** Records must exist in this transaction */
-          const exists = await dboTx.sql("SELECT * FROM insert_rules WHERE id = ${id}", row, { returnType: "row" });
-          const existsd = await dboTx.insert_rules.findOne({ id: row.id });
-          if(row.id !== exists.id || row.id !== existsd.id){
-            console.error("postValidate failed");
-            // process.exit(1) 
-          }
-          if(row.name === "fail") throw "Failed";
-          return undefined
-        }
-      }
-    },
-    uuid_text: {
-      insert: {
-        fields: "*",
-        forcedData: {
-          id: 'c81089e1-c4c1-45d7-a73d-e2d613cb7c3e'
-        }
-      },
-      update: {
-        fields: [],
-        dynamicFields: [{
-          fields: { id: 1 },
-          filter: {
-            id: 'c81089e1-c4c1-45d7-a73d-e2d613cb7c3e'
-          }
-        }]
-      }
-    },
-    "prostgles_test.basic": "*",
-    "prostgles_test.basic1": "*",
-    "prostgles_test.mv_basic1": "*",
-    [`"""quoted0"""`]: "*",
-    [`"""quoted1"""`]: "*",
-    [`"""quoted2"""`]: "*",
-    symbols: "*",
-    trades: "*",
-  };
-  
-  return res;
-}

package/tests/server/testTableConfig.ts

@@ -1,156 +0,0 @@
-import type { TableConfig } from 'prostgles-server/dist/TableConfig/TableConfig';
-
-export const testTableConfig: TableConfig<{ en: 1, fr: 1 }> = {
-
-  tr2: {
-    // dropIfExists: true,
-    columns: {
-      t1: { label: { fr: "fr_t1" }, info: { hint: "hint...", min: "a", max: "b" } },
-      t2: { label: { en: "en_t2" } },
-    },
-    triggers: {
-      atLeastOneA: {
-        actions: ["delete", "update"],
-        forEach: "statement",
-        type: "after",
-        query: `
-          DECLARE
-          x_rec record;
-          BEGIN
-
-            IF NOT EXISTS(SELECT * FROM tr2 WHERE t1 = 'a' AND t2 = 'b') THEN
-              RAISE EXCEPTION 'Must have at least one row with t1 = a AND t2 = b';
-            END IF;
-
-            RETURN NULL;
-          END;
-        `
-      }
-    }
-  },
-  users_public_info: {
-    // dropIfExists: true,
-    columns: {
-      id: "SERIAL PRIMARY KEY",
-      name: "TEXT",
-      // avatar: `UUID REFERENCES media ON DELETE CASCADE`
-      avatar: `UUID`,
-      sid: `TEXT`,
-    }
-  },
-  users: {
-    dropIfExists: true,
-    columns: {
-      id:           { sqlDefinition: `SERIAL PRIMARY KEY ` },
-      email:        { sqlDefinition: `TEXT NOT NULL` },
-      status:       { enum: ["active", "disabled", "pending"] },
-      preferences:  { 
-        jsonbSchemaType: { 
-          showIntro:  { type: "boolean", optional: true },
-          theme:      { enum: ["light", "dark", "auto"], optional: true },
-          others: 		{ type: "any[]" }
-        } 
-      },
-    }
-  },
-  tjson: {
-    dropIfExists: true,
-    columns: {
-      json: { jsonbSchemaType: { 
-          a: { type: "boolean" },
-          arr: { enum: ["1", "2", "3"] },
-          arr1: { enum: [1, 2, 3] },
-          arr2: { type: "integer[]" },
-          arrStr: { type: "string[]", optional: true, nullable: true },
-          o: { optional: true, nullable: true, oneOfType: [
-            { o1: "integer" }, 
-            { o2:  "boolean" }
-          ] },
-        }  
-      },
-      colOneOf: { enum: ["a", "b", "c"] },
-      status:  {
-        nullable: true, 
-        jsonbSchema: {
-          oneOfType: [
-            { ok: { type: "string" } },
-            { err: { type: "string" } },
-            { 
-              loading: { type: { 
-                loaded: { type: "number" },
-                total: { type: "number" } 
-                } 
-              } 
-            }
-          ]
-        }
-      },
-      jsonOneOf: { 
-        nullable: true, 
-        jsonbSchema: { 
-          oneOfType: [
-            { command: { enum: ["a"] } },
-            { 
-              command: { enum: ["b"] },
-              option: { type: "integer[]" }
-            }
-          ]
-        }
-      },
-      table_config:	{ nullable: true, jsonbSchemaType: {
-          referencedTables: { optional: true, arrayOfType: { name: "string", minFiles: "number" } },
-          recType: {
-            nullable: true, optional: true, record: { keysEnum: ["a", "b"], values: { type: { bools: "boolean[]" } } }
-          }
-        }
-      }
-    }
-  },
-  lookup_col1: {
-    dropIfExistsCascade: true, 
-    isLookupTable: {
-      values: {
-        a: { description: "desc" },
-        b: {}
-      },
-    }
-  },
-  uuid_text: {
-    columns: {
-      id: "UUID",
-      col1: {
-        references: {
-          tableName: "lookup_col1",
-          nullable: true,
-        }
-      },
-      col2: {
-        references: {
-          tableName: "lookup_col1",
-          nullable: true,
-        }
-      }
-    }
-  },
-  api_table: {
-    dropIfExists: true,
-    columns: {
-      id: "SERIAL PRIMARY KEY",
-    },
-    onMount: async ({ _db, dbo }) => {
-      await _db.any(`ALTER TABLE api_table ADD COLUMN col1 TEXT`);
-    }
-  },
-  rec_ref: {
-    columns: {
-      id: "SERIAL PRIMARY KEY",
-    }
-  },
-  rec: {
-    columns: {
-      id: "SERIAL PRIMARY KEY",
-      parent_id: "INTEGER REFERENCES rec",
-      recf: "INTEGER REFERENCES rec_ref",
-    }
-  }
-} 

package/tests/server/tsconfig.json

@@ -1,22 +0,0 @@
-{
-	"files": ["./index.ts"],
-	"compilerOptions": {
-		"target": "es2022",
-		"lib": [ "es2022" ],
-		"esModuleInterop" : true,
-		"allowSyntheticDefaultImports": true,
-    "resolveJsonModule": true,
-		"allowJs": true,
-		"module": "commonjs",
-    "moduleResolution": "Node10",
-		"declaration": true,
-		"declarationMap": true, 
-		"ignoreDeprecations": "5.0",
-		"skipLibCheck": true,
-    "outDir": "dist",
-	},
-	"exclude": [
-		"dist",
-		"DBoGenerated.d.ts"
-	]
-}

package/tests/serverOnlyQueries.spec.ts

@@ -1,32 +0,0 @@
-//@ts-ignore
-import type { DBHandlerServer } from "../dist/DboBuilder";
-import { test, describe } from "node:test";
-
-export const serverOnlyQueries = async (db: DBHandlerServer) => {
-  
-  await describe('Server Only Queries', async () => {
-    await test('Self reference recursion bug', async () => {
-      await db.rec.findOne!({ id: 1 }, { select: { "*": 1, rec_ref: "*" } });
-    });
-    await test('Transactions', async () => {
-      await db.tx!(async t => {
-        await t.items.insert!({ name: "tx_" });
-        const expect1 = await t.items.count!({ name: "tx_" });
-        const expect0 = await db.items.count!({ name: "tx_" });
-        if(expect0 !== 0 || expect1 !== 1) throw "db.tx failed";
-    
-        //throw "err"; // Any errors will revert all data-changing commands using the transaction object ( t )
-      });
-      const expect1 = await db.items.count!({ name: "tx_" });
-      if(expect1 !== 1) throw "db.tx failed";
-    });
-    
-    await test('TableConfig onMount works', async () => {
-      await db.api_table.findOne!({ id: 1 });
-      const newRow = await db.api_table.insert!({ }, { returning: "*" });
-      if(newRow.col1 !== null) {
-        throw "api_table onMount failed: col1 missing. Got: " + JSON.stringify(newRow);
-      }
-    }); 
-  });
-}

package/tests/test.sh

@@ -1,20 +0,0 @@
-#!/bin/bash
-cd client
-npm run build
-cd ../server
-
-if [ $# -eq 0 ]; then
-  # no args passed
-  rm -rf ./node-modules
-  npm i
-fi
-
-npm run build
-
-#npm run test-server 2>&1 ./server.log
-npm run test-server && \
-TEST_NAME="main"         npm run test-client && \
-TEST_NAME="useProstgles" npm run test-client && \
-TEST_NAME="files"        npm run test-client && \
-TEST_NAME="rest_api"     npm run test-client
-