@basictech/react 0.2.0-beta.7 → 0.2.0-beta.9

package/src/schema.ts

@@ -0,0 +1,159 @@
+// Basic Schema Library
+// utils for validating and interacting with Basic schemas
+import Ajv, { ErrorObject } from 'ajv'
+
+const basicJsonSchema = {
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "type": "object",
+    "properties": {
+        "project_id": {
+            "type": "string"
+        },
+        "namespace": {
+            "type": "string",
+        },
+        "version": {
+            "type": "integer",
+            "minimum": 0
+        },
+        "tables": {
+            "type": "object",
+            "patternProperties": {
+                "^[a-zA-Z0-9_]+$": {
+                    "type": "object",
+                    "properties": {
+                        "name": {
+                            "type": "string"
+                        },
+                        "type": {
+                            "type": "string",
+                            "enum": ["collection"]
+                        },
+                        "fields": {
+                            "type": "object",
+                            "patternProperties": {
+                                "^[a-zA-Z0-9_]+$": {
+                                    "type": "object",
+                                    "properties": {
+                                        "type": {
+                                            "type": "string",
+                                            "enum": ["string", "boolean", "number", "json"]
+                                        },
+                                        "indexed": {
+                                            "type": "boolean"
+                                        }, 
+                                        "required": {
+                                            "type": "boolean"
+                                        }
+                                    },
+                                    "required": ["type"]
+                                }
+                            },
+                            "additionalProperties": true
+                        }
+                    },
+                    "required": ["fields"]
+                }
+            },
+            "additionalProperties": true
+        }
+    },
+    "required": ["project_id", "version", "tables"]
+  }
+const ajv = new Ajv()
+const validator = ajv.compile(basicJsonSchema)
+
+type Schema = typeof basicJsonSchema
+
+function generateEmptySchema() {
+   
+}
+
+
+/**
+ * Validate a schema
+ * only checks if the schema is formatted correctly, not if can be published
+ * @param schema - The schema to validate
+ * @returns {valid: boolean, errors: any[]} - The validation result
+ */
+function validateSchema(schema: Schema) : {valid: boolean, errors: ErrorObject[]} {
+    const v = validator(schema)
+    return { 
+        valid: v,
+        errors: validator.errors || []
+    }
+}
+
+// type ErrorObject = {
+//     keyword: string;
+//     instancePath: string; 
+//     schemaPath: string;
+//     params: Record<string, any>;
+//     propertyName?: string;
+//     message?: string;
+//     schema?: any;
+//     parentSchema?: any;
+//     data?: any;
+// }
+
+
+function validateData(schema: any, table: string, data: Record<string, any>, checkRequired: boolean = true) {
+    const valid = validateSchema(schema)
+    if (!valid.valid) {
+        return { valid: false, errors: valid.errors, message: "Schema is invalid" }
+    }
+
+    const tableSchema = schema.tables[table]
+
+    if (!tableSchema) {
+        return { valid: false, errors: [{ message: `Table ${table} not found in schema` }], message: "Table not found" }
+    }
+
+    for (const [fieldName, fieldValue] of Object.entries(data)) {
+        const fieldSchema = tableSchema.fields[fieldName]
+        
+        if (!fieldSchema) {
+            return { 
+                valid: false, 
+                errors: [{ message: `Field ${fieldName} not found in schema` }],
+                message: "Invalid field"
+            }
+        }
+
+        const schemaType = fieldSchema.type
+        const valueType = typeof fieldValue
+
+        if (
+            (schemaType === 'string' && valueType !== 'string') ||
+            (schemaType === 'number' && valueType !== 'number') ||
+            (schemaType === 'boolean' && valueType !== 'boolean') ||
+            (schemaType === 'json' && valueType !== 'object')
+        ) {
+            return {
+                valid: false,
+                errors: [{ 
+                    message: `Field ${fieldName} should be type ${schemaType}, got ${valueType}` 
+                }],
+                message: "invalid type"
+            }
+        }
+    }
+
+    if (checkRequired) {
+        for (const [fieldName, fieldSchema] of Object.entries(tableSchema.fields)) {
+            if ((fieldSchema as { required?: boolean }).required && !data[fieldName]) {
+                return { valid: false, errors: [{ message: `Field ${fieldName} is required` }], message: "Required field missing" }
+            }
+        }
+    }
+
+    return { valid: true, errors: [] }
+}
+
+
+export {
+    validateSchema,
+    validateData,
+    generateEmptySchema
+}
+

package/src/sync/index.ts

@@ -2,14 +2,13 @@
 
 import { v7 as uuidv7 } from 'uuid';
 import { Dexie, PromiseExtended } from 'dexie';
-// if (typeof window !== 'undefined') {
-//   import('dexie-observable');
-// }
 import 'dexie-syncable';
 import 'dexie-observable';
 
 import { syncProtocol } from './syncProtocol'
 import { SERVER_URL, log } from '../config'
+
+import { validateSchema, validateData } from '../schema'
 syncProtocol()
 
 
@@ -149,14 +148,28 @@ export class BasicSync extends Dexie {
 
       // --- WRITE ---- // 
       add: (data: any) => {
-        log("Adding data to", name, data)
+        // log("Adding data to", name, data)
+
+        const valid = validateData(this.basic_schema, name, data)
+        if (!valid.valid) {
+          log('Invalid data', valid)
+          return Promise.reject({ ... valid })
+        }
+
         return this.table(name).add({
           id: uuidv7(),
           ...data
         })
+
       },
 
       put: (data: any) => {
+        const valid = validateData(this.basic_schema, name, data)
+        if (!valid.valid) {
+          log('Invalid data', valid)
+          return Promise.reject({ ... valid })
+        }
+
         return this.table(name).put({
           id: uuidv7(),
           ...data
@@ -164,6 +177,12 @@ export class BasicSync extends Dexie {
       },
 
       update: (id: string, data: any) => {
+        const valid = validateData(this.basic_schema, name, data, false)
+        if (!valid.valid) {
+          log('Invalid data', valid)
+          return Promise.reject({ ... valid })
+        }
+
         return this.table(name).update(id, data)
       },
 

package/src/sync/syncProtocol.js

@@ -86,6 +86,7 @@ export const syncProtocol = function () {
 
       // If socket is closed (network disconnected), inform framework and make it reconnect
       ws.onclose = function (event) {
+        // console.log('🙅 ws.onclose', event)
         onError("Socket closed: " + event.reason, RECONNECT_DELAY);
       };
 
@@ -124,7 +125,6 @@ export const syncProtocol = function () {
                 syncedRevision: syncedRevision,
               }),
             );
-          } else if (requestFromServer.type == "error") {
           } else if (requestFromServer.type == "changes") {
             applyRemoteChanges(
               requestFromServer.changes,