@statezero/core 0.1.4 → 0.1.6

package/dist/cli/commands/syncModels.js

@@ -159,7 +159,7 @@ const JS_MODEL_TEMPLATE = `/**
 
 import { Model, Manager, QuerySet, getModelClass } from '{{modulePath}}';
 import { wrapReactiveModel } from '{{modulePath}}';
-import schemaData from './{{className}}.schema.json';
+import schemaData from './{{toLowerCase className}}.schema.json';
 
 /**
  * Model-specific QuerySet implementation
@@ -499,6 +499,9 @@ Handlebars.registerHelper("ifDefaultProvided", function (defaultValue, options)
 Handlebars.registerHelper("isRequired", function (required) {
     return required ? "" : "?";
 });
+Handlebars.registerHelper("toLowerCase", function (str) {
+    return str.toLowerCase();
+});
 const jsTemplate = Handlebars.compile(JS_MODEL_TEMPLATE);
 const dtsTemplate = Handlebars.compile(TS_DECLARATION_TEMPLATE);
 // --------------------
@@ -511,9 +514,8 @@ const dtsTemplate = Handlebars.compile(TS_DECLARATION_TEMPLATE);
  * @returns {Promise<{model: string, relativePath: string}>}
  */
 async function generateSchemaForModel(backend, model) {
-    const authHeaders = backend.getAuthHeaders ? backend.getAuthHeaders() : {};
     const schemaUrl = `${backend.API_URL}/${model}/get-schema/`;
-    const schemaResponse = await axios.get(schemaUrl, authHeaders);
+    const schemaResponse = await axios.get(schemaUrl);
     /** @type {SchemaDefinition} */
     let schema;
     if (schemaResponse.data.components?.schemas?.[model]) {
@@ -1008,10 +1010,7 @@ async function main() {
         const backend = backendConfigs[key];
         backend.NAME = key;
         try {
-            const authHeaders = backend.getAuthHeaders
-                ? backend.getAuthHeaders()
-                : {};
-            const response = await axios.get(`${backend.API_URL}/models/`, authHeaders);
+            const response = await axios.get(`${backend.API_URL}/models/`);
             return { backend, models: response.data };
         }
         catch (error) {

package/dist/flavours/django/model.js

@@ -1,10 +1,10 @@
-import { Manager } from './manager.js';
-import { ValidationError } from './errors.js';
-import { modelStoreRegistry } from '../../syncEngine/registries/modelStoreRegistry.js';
-import { isNil } from 'lodash-es';
-import { QueryExecutor } from './queryExecutor';
-import { wrapReactiveModel } from '../../reactiveAdaptor.js';
-import { DateParsingHelpers } from './dates.js';
+import { Manager } from "./manager.js";
+import { ValidationError } from "./errors.js";
+import { modelStoreRegistry } from "../../syncEngine/registries/modelStoreRegistry.js";
+import { isNil } from "lodash-es";
+import { QueryExecutor } from "./queryExecutor";
+import { wrapReactiveModel } from "../../reactiveAdaptor.js";
+import { DateParsingHelpers } from "./dates.js";
 /**
  * A constructor for a Model.
  *
@@ -54,7 +54,7 @@ export class Model {
      * Instantiate from pk using queryset scoped singletons
      */
     static fromPk(pk, querySet) {
-        let qsId = querySet ? querySet.__uuid : '';
+        let qsId = querySet ? querySet.__uuid : "";
         let key = `${qsId}__${this.configKey}__${this.modelName}__${pk}`;
         if (!this.instanceCache.has(key)) {
             const instance = new this();
@@ -90,15 +90,15 @@ export class Model {
             // footgun - fieldInfo.ModelClass() calls the arrow function that lazily gets the model class
             let relPkField = fieldInfo.ModelClass().primaryKeyField;
             switch (fieldInfo.relationshipType) {
-                case 'many-to-many':
+                case "many-to-many":
                     // value is an array
                     if (!Array.isArray(value) && value)
                         throw new Error(`Data corruption: m2m field for ${ModelClass.modelName} stored as ${value}`);
                     // set each pk to the full model object for that pk
-                    value = value.map(pk => fieldInfo.ModelClass().fromPk(pk));
+                    value = value.map((pk) => fieldInfo.ModelClass().fromPk(pk));
                     break;
-                case 'one-to-one':
-                case 'foreign-key':
+                case "one-to-one":
+                case "foreign-key":
                     // footgun - fieldInfo.ModelClass() calls the arrow function that lazily gets the model class
                     if (!isNil(value))
                         value = fieldInfo.ModelClass().fromPk(value);
@@ -135,13 +135,13 @@ export class Model {
             return;
         const allowedFields = this.fields;
         for (const key of Object.keys(data)) {
-            if (key === 'repr' || key === 'type')
+            if (key === "repr" || key === "type")
                 continue;
             // Handle nested fields by splitting on double underscore
             // and taking just the base field name
-            const baseField = key.split('__')[0];
+            const baseField = key.split("__")[0];
             if (!allowedFields.includes(baseField)) {
-                let errorMsg = `Invalid field: ${baseField}. Allowed fields are: ${allowedFields.join(', ')}`;
+                let errorMsg = `Invalid field: ${baseField}. Allowed fields are: ${allowedFields.join(", ")}`;
                 console.error(errorMsg);
                 throw new ValidationError(errorMsg);
             }
@@ -165,6 +165,18 @@ export class Model {
             if (storedValue)
                 value = storedValue[field];
         }
+        if (ModelClass.relationshipFields &&
+            ModelClass.relationshipFields.has(field) &&
+            value) {
+            let fieldInfo = ModelClass.relationshipFields.get(field);
+            switch (fieldInfo.relationshipType) {
+                case "many-to-many":
+                    return value.map((instance) => instance.pk ? instance.pk : instance);
+                case "one-to-one":
+                case "foreign-key":
+                    return value.pk ? value.pk : value;
+            }
+        }
         return value;
     }
     /**
@@ -192,16 +204,20 @@ export class Model {
     async save() {
         const ModelClass = this.constructor;
         const pkField = ModelClass.primaryKeyField;
-        const querySet = !this.pk ? ModelClass.objects.newQuerySet() : ModelClass.objects.filter({ [pkField]: this.pk });
+        const querySet = !this.pk
+            ? ModelClass.objects.newQuerySet()
+            : ModelClass.objects.filter({ [pkField]: this.pk });
         const data = this.serialize();
         let instance;
         if (!this.pk) {
             // Create new instance
-            instance = await QueryExecutor.execute(querySet, 'create', { data });
+            instance = await QueryExecutor.execute(querySet, "create", { data });
         }
         else {
             // Update existing instance
-            instance = await QueryExecutor.execute(querySet, 'update_instance', { data });
+            instance = await QueryExecutor.execute(querySet, "update_instance", {
+                data,
+            });
         }
         this._pk = instance.pk;
         this._data = {};
@@ -218,14 +234,14 @@ export class Model {
      */
     async delete() {
         if (!this.pk) {
-            throw new Error('Cannot delete unsaved instance');
+            throw new Error("Cannot delete unsaved instance");
         }
         const ModelClass = this.constructor;
         const pkField = ModelClass.primaryKeyField;
         const querySet = ModelClass.objects.filter({ [pkField]: this.pk });
         // Pass the instance data with primary key as the args
         const args = { [pkField]: this.pk };
-        const result = await QueryExecutor.execute(querySet, 'delete_instance', args);
+        const result = await QueryExecutor.execute(querySet, "delete_instance", args);
         // result -> [deletedCount, { [modelName]: deletedCount }];
         return result;
     }
@@ -237,10 +253,12 @@ export class Model {
      */
     async refreshFromDb() {
         if (!this.pk) {
-            throw new Error('Cannot refresh unsaved instance');
+            throw new Error("Cannot refresh unsaved instance");
         }
         const ModelClass = this.constructor;
-        const fresh = await ModelClass.objects.get({ [ModelClass.primaryKeyField]: this.pk });
+        const fresh = await ModelClass.objects.get({
+            [ModelClass.primaryKeyField]: this.pk,
+        });
         // clear the current data and fresh data will flow
         this._data = {};
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statezero/core",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "type": "module",
   "module": "ESNext",
   "description": "The type-safe frontend client for StateZero - connect directly to your backend models with zero boilerplate",