prostgles-server 2.0.175 → 2.0.178

package/lib/PublishParser.ts

@@ -4,7 +4,7 @@ import { CommonTableRules, Filter, isPlainObject, LocalParams, PRGLIOSocket, Tab
 import { Prostgles, DBHandlerServer, DB, TABLE_METHODS } from "./Prostgles";
 import type { DBOFullyTyped, PublishFullyTyped } from "./DBSchemaBuilder";
 export type Method = (...args: any) => ( any | Promise<any> );
-export type PublishMethods<S extends DBSchema> = (params: PublishParams<S>) => { [key:string]: Method } | Promise<{ [key:string]: Method }>;
+export type PublishMethods<S extends DBSchema | undefined = undefined> = (params: PublishParams<S>) => { [key:string]: Method } | Promise<{ [key:string]: Method }>;
 
 export type Awaitable<T> = T | Promise<T>;
 
@@ -129,12 +129,12 @@ export type UpdateRequestData<R extends AnyObject = AnyObject> = UpdateRequestDa
 export type ValidateRow<R extends AnyObject = AnyObject> = (row: R) => R | Promise<R>;
 export type ValidateUpdateRow<R extends AnyObject = AnyObject> = (args: { update: Partial<R>, filter: FullFilter<R> }) => R | Promise<R>;
 
-export type SelectRule<S extends DBTableSchema = any> = {
+export type SelectRule<S extends DBTableSchema | undefined = undefined> = {
 
     /**
      * Fields allowed to be selected.   Tip: Use false to exclude field
      */
-    fields: FieldFilter<DBSchemaColumns<S["columns"]>>;
+    fields: FieldFilter<S extends DBTableSchema? DBSchemaColumns<S["columns"]> : AnyObject>;
 
     /**
      * The maximum number of rows a user can get in a select query. null by default. Unless a null or higher limit is specified 100 rows will be returned by the default
@@ -144,12 +144,12 @@ export type SelectRule<S extends DBTableSchema = any> = {
     /**
      * Filter added to every query (e.g. user_id) to restrict access
      */
-    forcedFilter?: FullFilter<DBSchemaColumns<S["columns"]>>;
+    forcedFilter?: FullFilter<S extends DBTableSchema? DBSchemaColumns<S["columns"]> : AnyObject>;
 
     /**
      * Fields user can filter by 
      * */
-    filterFields?: FieldFilter<DBSchemaColumns<S["columns"]>>;
+    filterFields?: FieldFilter<S extends DBTableSchema? DBSchemaColumns<S["columns"]> : AnyObject>;
 
     /**
      * Validation logic to check/update data for each request
@@ -157,39 +157,39 @@ export type SelectRule<S extends DBTableSchema = any> = {
     validate?(args: SelectRequestData): SelectRequestData | Promise<SelectRequestData>;
 
 }
-export type InsertRule<S extends DBTableSchema = any> = {
+export type InsertRule<S extends DBTableSchema | undefined = undefined> = {
 
     /**
      * Fields allowed to be inserted.   Tip: Use false to exclude field
      */
-    fields: FieldFilter<DBSchemaColumns<S["columns"]>>;
+    fields: SelectRule<S>["fields"]
 
     /**
      * Data to include/overwrite on each insert
      */
-    forcedData?: Partial<DBSchemaColumns<S["columns"]>>;
+    forcedData?: Partial<S extends DBTableSchema? DBSchemaColumns<S["columns"]> : AnyObject>;
 
     /**
      * Fields user can view after inserting
      */
-    returningFields?: FieldFilter<DBSchemaColumns<S["columns"]>>;
+    returningFields?: SelectRule<S>["fields"]
 
     /**
      * Validation logic to check/update data for each request. Happens before publish rule checks (for fields, forcedData/forcedFilter)
      */
-    preValidate?: ValidateRow<DBSchemaColumns<S["columns"]>>;
+    preValidate?: ValidateRow<S extends DBTableSchema? DBSchemaColumns<S["columns"]> : AnyObject>;
 
     /**
      * Validation logic to check/update data for each request. Happens after publish rule checks (for fields, forcedData/forcedFilter)
      */
-    validate?: ValidateRow<DBSchemaColumns<S["columns"]>>;
+    validate?: InsertRule<S>["preValidate"]
 }
-export type UpdateRule<S extends DBTableSchema = any> = {
+export type UpdateRule<S extends DBTableSchema | undefined = undefined> = {
 
     /**
      * Fields allowed to be updated.   Tip: Use false/0 to exclude field
      */
-    fields: FieldFilter<DBSchemaColumns<S["columns"]>>;
+    fields: SelectRule<S>["fields"]
     
     /**
      * Row level FGAC
@@ -199,71 +199,71 @@ export type UpdateRule<S extends DBTableSchema = any> = {
      * Specify in decreasing order of specificity otherwise a more general filter will match first
      */
     dynamicFields?: {
-      filter: FullFilter<DBSchemaColumns<S["columns"]>>;
-      fields: FieldFilter<DBSchemaColumns<S["columns"]>>;
+      filter: SelectRule<S>["forcedFilter"]
+      fields: SelectRule<S>["fields"]
     }[];
 
     /**
      * Filter added to every query (e.g. user_id) to restrict access
      * This filter cannot be updated
      */
-    forcedFilter?: FullFilter<DBSchemaColumns<S["columns"]>>;
+    forcedFilter?: SelectRule<S>["forcedFilter"]
 
     /**
      * Data to include/overwrite on each updatDBe
      */
-    forcedData?: Partial<DBSchemaColumns<S["columns"]>>
+    forcedData?: InsertRule<S>["forcedData"]
 
     /**
      * Fields user can use to find the updates
      */
-    filterFields?: FieldFilter<DBSchemaColumns<S["columns"]>>;
+    filterFields?: SelectRule<S>["fields"]
 
     /**
      * Fields user can view after updating
      */
-    returningFields?: FieldFilter<DBSchemaColumns<S["columns"]>>;
+    returningFields?: SelectRule<S>["fields"]
 
     /**
      * Validation logic to check/update data for each request
      */
-    validate?: ValidateUpdateRow<DBSchemaColumns<S["columns"]>>;
+    validate?: ValidateUpdateRow<S extends DBTableSchema? DBSchemaColumns<S["columns"]> : AnyObject>;
 
 };
 
-export type DeleteRule<S extends DBTableSchema = any> = {
+export type DeleteRule<S extends DBTableSchema | undefined = undefined> = {
     
     /**
      * Filter added to every query (e.g. user_id) to restrict access
      */
-    forcedFilter?: FullFilter<DBSchemaColumns<S["columns"]>>;
+    forcedFilter?: FullFilter<S extends DBTableSchema? DBSchemaColumns<S["columns"]> : AnyObject>;
 
     /**
      * Fields user can filter by
      */
-    filterFields?: FieldFilter<DBSchemaColumns<S["columns"]>>;
+    filterFields?: FieldFilter<S extends DBTableSchema? DBSchemaColumns<S["columns"]> : AnyObject>;
 
     /**
      * Fields user can view after deleting
      */
-    returningFields?: FieldFilter<DBSchemaColumns<S["columns"]>>;
+    returningFields?: FieldFilter<S extends DBTableSchema? DBSchemaColumns<S["columns"]> : AnyObject>;
 
     /**
      * Validation logic to check/update data for each request
      */
-    validate?(...args: any[]): UpdateRequestData<DBSchemaColumns<S["columns"]>>;
+    validate?(...args: any[]): UpdateRequestData<S extends DBTableSchema? DBSchemaColumns<S["columns"]> : AnyObject>;
 }
-export type SyncRule<S extends DBTableSchema = any> = {
+export type SyncRule<S extends DBTableSchema | undefined = undefined> = {
     
     /**
      * Primary keys used in updating data
      */
-    id_fields: string[];
+    id_fields: S extends DBTableSchema? (keyof S["dataTypes"])[] : string[];
     
     /**
      * Numerical incrementing fieldname (last updated timestamp) used to sync items
      */
-    synced_field: string;
+    synced_field:  S extends DBTableSchema? (keyof S["dataTypes"]) : string;
 
     /**
      * EXPERIMENTAL. Disabled by default. If true then server will attempt to delete any records missing from client.
@@ -284,25 +284,25 @@ export type SubscribeRule = {
   throttle?: number;
 }
 
-export type ViewRule<S extends DBTableSchema> = CommonTableRules & {
+export type ViewRule<S extends DBTableSchema | undefined = undefined> = CommonTableRules & {
   /**
    * What can be read from the table
    */
   select?: SelectRule<S>;
 };
-export type TableRule<S extends DBTableSchema = any> = ViewRule<S> & {
+export type TableRule<S extends DBTableSchema | undefined = undefined> = ViewRule<S> & {
   insert?: InsertRule<S>;
   update?: UpdateRule<S>;
   delete?: DeleteRule<S>;
   sync?: SyncRule<S>;
   subscribe?: SubscribeRule;
 };
-export type PublishViewRule<S extends DBTableSchema = any> = {
+export type PublishViewRule<S extends DBTableSchema | undefined = undefined> = {
   select?: SelectRule<S> | PublishAllOrNothing
   getColumns?: PublishAllOrNothing;
   getInfo?: PublishAllOrNothing;
 };
-export type PublishTableRule<S extends DBTableSchema = any> = PublishViewRule<S> & {
+export type PublishTableRule<S extends DBTableSchema | undefined = undefined> = PublishViewRule<S> & {
   insert?: InsertRule<S> | PublishAllOrNothing
   update?: UpdateRule<S> | PublishAllOrNothing
   delete?: DeleteRule<S> | PublishAllOrNothing
@@ -327,7 +327,7 @@ export type ParsedPublishTable = {
 // export type Publish = {
 //     tablesOrViews: {[key:string]: TableRule | ViewRule | "*" }
 // }
-export type PublishParams<S extends DBSchema = any> = {
+export type PublishParams<S extends DBSchema | undefined = undefined> = {
   sid?: string;
   dbo: DBOFullyTyped<S>;
   db?: DB;
@@ -336,14 +336,14 @@ export type PublishParams<S extends DBSchema = any> = {
 }
 export type RequestParams = { dbo?: DBHandlerServer, socket?: any };
 export type PublishAllOrNothing = true | "*" | false | null;
-export type PublishObject<Schema extends DBSchema = any> = { 
+export type PublishObject<Schema extends DBSchema | undefined = undefined> = { 
     [table_name: string]: (PublishTableRule | PublishViewRule | PublishAllOrNothing ) 
 };
 export type ParsedPublishTables = { 
   [table_name: string]: ParsedPublishTable
 };
-export type PublishedResult<Schema extends DBSchema = any> = PublishAllOrNothing | PublishFullyTyped<Schema> ;
-export type Publish<Schema extends DBSchema = any> = PublishedResult<Schema> | ((params: PublishParams<Schema>) => Awaitable<PublishedResult<Schema>>);
+export type PublishedResult<Schema extends DBSchema | undefined = undefined> = PublishAllOrNothing | PublishFullyTyped<Schema> ;
+export type Publish<Schema extends DBSchema | undefined = undefined> = PublishedResult<Schema> | ((params: PublishParams<Schema>) => Awaitable<PublishedResult<Schema>>);
 
 export class PublishParser {
   publish: any;

package/lib/index.ts

@@ -1,7 +1,7 @@
 import { Prostgles, ProstglesInitOptions } from "./Prostgles";
 import { DBSchema } from "prostgles-types";
 
-function prostgles<S extends DBSchema = any>(params: ProstglesInitOptions<S>){
+function prostgles<S extends DBSchema | undefined = undefined>(params: ProstglesInitOptions<S>){
 
     let prgl = new Prostgles<S>(params as any);
     return prgl.init(params.onReady);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prostgles-server",
-  "version": "2.0.175",
+  "version": "2.0.178",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/tests/client/PID.txt

@@ -1 +1 @@
-77066
+85322

package/tests/client/tsconfig.json

@@ -10,6 +10,7 @@
 		// "rootDir": ".",
 		// "declaration": true,
 		// "declarationMap": true,
+		"keyofStringsOnly": true
 	},
 	"exclude": [
 		"dist"

package/tests/isomorphic_queries.ts

@@ -457,7 +457,7 @@ export default async function isomorphic(db: Partial<DBHandlerServer> | Partial<
     assert.deepStrictEqual(MonAgg, [{ added: "Dec", public: '2' }]);
 
     // Returning
-    const returningParam = { returning: { id: 1, name: 1, public: 1 , $rowhash: 1, added_day: { "$day": ["added"] } }} ;  //   ctid: 1,
+    const returningParam: Parameters<typeof db.items4_pub.insert>[1] = { returning: { id: 1, name: 1, public: 1 , $rowhash: 1, added_day: { "$day": ["added"] } }} ;  //   ctid: 1,
     let i = await db.items4_pub.insert( { name: "abc123", public: "public data", added: new Date('04 Dec 1995 00:12:00 GMT') }, returningParam);
     assert.deepStrictEqual(i, { id: 1,  name: 'abc123', public: 'public data', $rowhash: '347c26babad535aa697a794af89195fe', added_day: 'monday'  }); //  , ctid: '(0,1)'
   

package/tests/server/DBoGenerated.d.ts

@@ -3,9 +3,6 @@
 
  /* SCHEMA DEFINITON. Table names have been altered to work with Typescript */
 /* DBO Definition. Isomorphic */
-undefined tx: (t: TxCB) => Promise<any | void> ;
-};
-
 
 type DBSchema = {
   "\"*\"": {

package/tests/server/package-lock.json

@@ -21,7 +21,7 @@
     },
     "../..": {
       "name": "prostgles-server",
-      "version": "2.0.174",
+      "version": "2.0.177",
       "license": "MIT",
       "dependencies": {
         "@aws-sdk/client-s3": "^3.95.0",

package/tests/server/tsconfig.json

@@ -12,6 +12,7 @@
 		// "rootDir": ".",
 		// "declaration": true,
 		// "declarationMap": true,
+		"keyofStringsOnly": true
 	},
 	"exclude": [
 		"dist",