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

package/dist/index.mjs

@@ -12,7 +12,6 @@ import "dexie-observable";
 import { Dexie } from "dexie";
 
 // src/config.ts
-import Ajv from "ajv";
 var SERVER_URL = "https://api.basic.tech";
 var log = (...args) => {
   try {
@@ -22,65 +21,6 @@ var log = (...args) => {
   } catch (e) {
   }
 };
-var 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"
-                    },
-                    "primary": {
-                      "type": "boolean"
-                    },
-                    "indexed": {
-                      "type": "boolean"
-                    }
-                  },
-                  "required": ["type"]
-                }
-              },
-              "additionalProperties": true
-            }
-          },
-          "required": ["fields"]
-        }
-      },
-      "additionalProperties": true
-    }
-  },
-  "required": ["project_id", "version", "tables"]
-};
-var ajv = new Ajv();
-var validator = ajv.compile(basicJsonSchema);
 
 // src/sync/syncProtocol.js
 var syncProtocol = function() {
@@ -138,7 +78,6 @@ var syncProtocol = function() {
                 syncedRevision
               })
             );
-          } else if (requestFromServer.type == "error") {
           } else if (requestFromServer.type == "changes") {
             applyRemoteChanges(
               requestFromServer.changes,
@@ -186,6 +125,117 @@ var syncProtocol = function() {
   });
 };
 
+// src/schema.ts
+import Ajv from "ajv";
+var 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"]
+};
+var ajv = new Ajv();
+var validator = ajv.compile(basicJsonSchema);
+function generateEmptySchema() {
+}
+function validateSchema(schema) {
+  const v = validator(schema);
+  return {
+    valid: v,
+    errors: validator.errors || []
+  };
+}
+function validateData(schema, table, data, checkRequired = 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.required && !data[fieldName]) {
+        return { valid: false, errors: [{ message: `Field ${fieldName} is required` }], message: "Required field missing" };
+      }
+    }
+  }
+  return { valid: true, errors: [] };
+}
+
 // src/sync/index.ts
 syncProtocol();
 var BasicSync = class extends Dexie2 {
@@ -253,19 +303,33 @@ var BasicSync = class extends Dexie2 {
       ref: this.table(name),
       // --- WRITE ---- // 
       add: (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) => {
+        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
         });
       },
       update: (id, data) => {
+        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);
       },
       delete: (id) => {
@@ -336,7 +400,7 @@ async function deleteRecord({ projectId, accountId, tableName, id, token }) {
 import { jsx, jsxs } from "react/jsx-runtime";
 var BasicContext = createContext({
   unicorn: "\u{1F984}",
-  isLoaded: false,
+  isAuthReady: false,
   isSignedIn: false,
   user: null,
   signout: () => {
@@ -347,7 +411,7 @@ var BasicContext = createContext({
   }),
   getSignInLink: () => "",
   db: {},
-  dbStatus: "OFFLINE" /* OFFLINE */
+  dbStatus: "LOADING" /* LOADING */
 });
 function getSyncStatus(statusCode) {
   switch (statusCode) {
@@ -368,21 +432,21 @@ function getSyncStatus(statusCode) {
   }
 }
 function BasicProvider({ children, project_id, schema, debug = false }) {
-  const [isLoaded, setIsLoaded] = useState(false);
+  const [isAuthReady, setIsAuthReady] = useState(false);
   const [isSignedIn, setIsSignedIn] = useState(false);
   const [token, setToken] = useState(null);
-  const [authCode, setAuthCode] = useState(null);
   const [user, setUser] = useState({});
   const [dbStatus, setDbStatus] = useState("LOADING" /* LOADING */);
-  const syncRef = useRef(null);
   const [error, setError] = useState(null);
+  const syncRef = useRef(null);
   useEffect(() => {
     function initDb() {
-      if (!validator(schema)) {
-        log("Basic Schema is invalid!", validator.errors);
+      const valid = validateSchema(schema);
+      if (!valid.valid) {
+        log("Basic Schema is invalid!", valid.errors);
         console.group("Schema Errors");
         let errorMessage = "";
-        validator.errors.forEach((error2, index) => {
+        valid.errors.forEach((error2, index) => {
           log(`${index + 1}:`, error2.message, ` - at ${error2.instancePath}`);
           errorMessage += `${index + 1}: ${error2.message} - at ${error2.instancePath}
 `;
@@ -396,20 +460,30 @@ function BasicProvider({ children, project_id, schema, debug = false }) {
         return null;
       }
       if (!syncRef.current) {
+        log("Initializing BasicDB");
         syncRef.current = new BasicSync("basicdb", { schema });
-        syncRef.current.handleStatusChange((status, url) => {
-          setDbStatus(getSyncStatus(status));
-        });
-        syncRef.current.syncable.getStatus().then((status) => {
-          log("sync status", getSyncStatus(status));
-        });
       }
     }
     initDb();
   }, []);
+  useEffect(() => {
+    if (!syncRef.current) {
+      return;
+    }
+    syncRef.current.syncable.on("statusChanged", (status, url) => {
+      setDbStatus(getSyncStatus(status));
+    });
+    syncRef.current.syncable.getStatus().then((status) => {
+      setDbStatus(getSyncStatus(status));
+    });
+  }, [syncRef.current]);
   const connectToDb = async () => {
     const tok = await getToken();
-    log("connecting to db...", tok.substring(0, 10));
+    if (!tok) {
+      log("no token found");
+      return;
+    }
+    log("connecting to db...");
     syncRef.current.connect({ access_token: tok }).catch((e) => {
       log("error connecting to db", e);
     });
@@ -421,13 +495,14 @@ function BasicProvider({ children, project_id, schema, debug = false }) {
   }, [token]);
   const getSignInLink = () => {
     log("getting sign in link...");
-    const randomState = Math.random().toString(36).substring(7);
+    const randomState = Math.random().toString(36).substring(6);
+    localStorage.setItem("basic_auth_state", randomState);
     let baseUrl2 = "https://api.basic.tech/auth/authorize";
     baseUrl2 += `?client_id=${project_id}`;
     baseUrl2 += `&redirect_uri=${encodeURIComponent(window.location.href)}`;
     baseUrl2 += `&response_type=code`;
     baseUrl2 += `&scope=openid`;
-    baseUrl2 += `&state=1234zyx`;
+    baseUrl2 += `&state=${randomState}`;
     return baseUrl2;
   };
   const signin = () => {
@@ -440,8 +515,8 @@ function BasicProvider({ children, project_id, schema, debug = false }) {
     setUser({});
     setIsSignedIn(false);
     setToken(null);
-    setAuthCode(null);
     document.cookie = `basic_token=; Secure; SameSite=Strict`;
+    localStorage.removeItem("basic_auth_state");
   };
   const getToken = async () => {
     log("getting token...");
@@ -491,17 +566,25 @@ function BasicProvider({ children, project_id, schema, debug = false }) {
   useEffect(() => {
     localStorage.setItem("basic_debug", debug ? "true" : "false");
     try {
-      let cookie_token = getCookie("basic_token");
-      if (cookie_token !== "") {
-        setToken(JSON.parse(cookie_token));
-      }
       if (window.location.search.includes("code")) {
         let code = window.location?.search?.split("code=")[1].split("&")[0];
-        setAuthCode(code);
+        const state = localStorage.getItem("basic_auth_state");
+        if (!state || state !== window.location.search.split("state=")[1].split("&")[0]) {
+          log("error: auth state does not match");
+          setIsAuthReady(true);
+          localStorage.removeItem("basic_auth_state");
+          window.history.pushState({}, document.title, "/");
+          return;
+        }
+        localStorage.removeItem("basic_auth_state");
         fetchToken(code);
-        window.history.pushState({}, document.title, "/");
       } else {
-        setIsLoaded(true);
+        let cookie_token = getCookie("basic_token");
+        if (cookie_token !== "") {
+          setToken(JSON.parse(cookie_token));
+        } else {
+          setIsAuthReady(true);
+        }
       }
     } catch (e) {
       log("error getting cookie", e);
@@ -509,6 +592,7 @@ function BasicProvider({ children, project_id, schema, debug = false }) {
   }, []);
   useEffect(() => {
     async function fetchUser(acc_token) {
+      console.info("fetching user");
       const user2 = await fetch("https://api.basic.tech/auth/userInfo", {
         method: "GET",
         headers: {
@@ -520,14 +604,18 @@ function BasicProvider({ children, project_id, schema, debug = false }) {
         return;
       } else {
         document.cookie = `basic_token=${JSON.stringify(token)}; Secure; SameSite=Strict`;
+        if (window.location.search.includes("code")) {
+          window.history.pushState({}, document.title, "/");
+        }
         setUser(user2);
         setIsSignedIn(true);
-        setIsLoaded(true);
+        setIsAuthReady(true);
       }
     }
     async function checkToken() {
       if (!token) {
         log("error: no user token found");
+        setIsAuthReady(true);
         return;
       }
       const decoded = jwtDecode(token?.access_token);
@@ -542,7 +630,6 @@ function BasicProvider({ children, project_id, schema, debug = false }) {
     }
     if (token) {
       checkToken();
-      setIsLoaded(true);
     }
   }, [token]);
   const db_ = (tableName) => {
@@ -576,7 +663,7 @@ function BasicProvider({ children, project_id, schema, debug = false }) {
   };
   return /* @__PURE__ */ jsxs(BasicContext.Provider, { value: {
     unicorn: "\u{1F984}",
-    isLoaded,
+    isAuthReady,
     isSignedIn,
     user,
     signout,
@@ -627,8 +714,14 @@ function useQuery(queryable) {
     return queryable;
   }, [queryable], []);
 }
+var sc = {
+  validateSchema,
+  validateData,
+  generateEmptySchema
+};
 export {
   BasicProvider,
+  sc,
   useBasic,
   useQuery
 };