@statezero/core 0.1.0

package/dist/adaptors/react/composables.d.ts

@@ -0,0 +1 @@
+export function useQueryset(querysetFactory: any): any;

package/dist/adaptors/react/composables.js

@@ -0,0 +1,4 @@
+export function useQueryset(querysetFactory) {
+    console.warn("React environments are not currently supported");
+    return querysetFactory;
+}

package/dist/adaptors/react/index.d.ts

@@ -0,0 +1 @@
+export { useQueryset } from "./composables.js";

package/dist/adaptors/react/index.js

@@ -0,0 +1 @@
+export { useQueryset } from './composables.js';

package/dist/adaptors/vue/composables.d.ts

@@ -0,0 +1,2 @@
+export function useQueryset(querysetFactory: any): import("vue").ComputedRef<any>;
+export const querysets: Map<any, any>;

package/dist/adaptors/vue/composables.js

@@ -0,0 +1,36 @@
+import { computed, getCurrentInstance, onBeforeUnmount } from 'vue';
+import { querysetStoreRegistry } from '../../syncEngine/registries/querysetStoreRegistry';
+import { metricRegistry } from '../../syncEngine/registries/metricRegistry';
+import { syncManager } from '../../syncEngine/sync';
+import { v7 } from 'uuid';
+syncManager.followAllQuerysets = false;
+export const querysets = new Map(); // Map of composableId -> queryset
+function updateSyncManager() {
+    // Get unique querysets from all active composables
+    const uniqueQuerysets = new Set(querysets.values());
+    syncManager.followedQuerysets = uniqueQuerysets;
+}
+export function useQueryset(querysetFactory) {
+    const instance = getCurrentInstance();
+    if (!instance) {
+        throw new Error('useQueryset must be called within a component setup function');
+    }
+    const composableId = v7();
+    let lastQueryset = null;
+    onBeforeUnmount(() => {
+        querysets.delete(composableId);
+        updateSyncManager();
+    });
+    return computed(() => {
+        const result = querysetFactory();
+        const original = result?.original || result;
+        const queryset = original?.queryset || original;
+        // Only update if queryset actually changed
+        if (lastQueryset !== queryset) {
+            querysets.set(composableId, queryset);
+            updateSyncManager();
+            lastQueryset = queryset;
+        }
+        return result;
+    });
+}

package/dist/adaptors/vue/index.d.ts

@@ -0,0 +1,2 @@
+export { useQueryset, querysets } from "./composables.js";
+export { ModelAdaptor, QuerySetAdaptor, MetricAdaptor } from "./reactivity.js";

package/dist/adaptors/vue/index.js

@@ -0,0 +1,2 @@
+export { useQueryset, querysets } from './composables.js';
+export { ModelAdaptor, QuerySetAdaptor, MetricAdaptor } from './reactivity.js';

package/dist/adaptors/vue/reactivity.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Adapts a model instance to a Vue reactive object by directly wrapping
+ * the instance and incrementing an internal version on relevant events.
+ *
+ * @param {Object} modelInstance - An instance of a model class with static modelName and primaryKeyField
+ * @param {Function} [reactivityFn=reactive] - Which Vue reactivity function to use (reactive or ref)
+ * @returns {import('vue').Reactive|import('vue').Ref} The reactive model instance, augmented with __version
+ */
+export function ModelAdaptor(modelInstance: Object, reactivityFn?: Function): any | import("vue").Ref;
+/**
+ * Adapts a queryset to a Vue reactive object and sets up event handling for queryset updates
+ *
+ * @param {Object} liveQuerySet - A LiveQueryset instance
+ * @param {Function} [reactivityFn=reactive] - Which Vue reactivity function to use (reactive or ref)
+ * @returns {import('vue').Reactive|import('vue').Ref} The reactive queryset
+ */
+export function QuerySetAdaptor(liveQuerySet: Object, reactivityFn?: Function): any | import("vue").Ref;
+export function MetricAdaptor(metric: any): any;

package/dist/adaptors/vue/reactivity.js

@@ -0,0 +1,125 @@
+import { reactive, ref, nextTick } from "vue";
+import { modelEventEmitter, querysetEventEmitter, metricEventEmitter } from "../../syncEngine/stores/reactivity.js";
+import { initEventHandler } from "../../syncEngine/stores/operationEventHandlers.js";
+import { isEqual, isNil } from 'lodash-es';
+import hash from 'object-hash';
+initEventHandler(); // Initialize event handler for model events
+const wrappedQuerysetCache = new Map();
+const wrappedMetricCache = new Map();
+/**
+ * Adapts a model instance to a Vue reactive object by directly wrapping
+ * the instance and incrementing an internal version on relevant events.
+ *
+ * @param {Object} modelInstance - An instance of a model class with static modelName and primaryKeyField
+ * @param {Function} [reactivityFn=reactive] - Which Vue reactivity function to use (reactive or ref)
+ * @returns {import('vue').Reactive|import('vue').Ref} The reactive model instance, augmented with __version
+ */
+export function ModelAdaptor(modelInstance, reactivityFn = reactive) {
+    const modelClass = modelInstance.constructor;
+    const modelName = modelClass.modelName;
+    const configKey = modelClass.configKey;
+    const pkField = modelClass.primaryKeyField;
+    // Make the model instance reactive using the specified function
+    const wrapper = reactivityFn(modelInstance);
+    const eventName = `${configKey}::${modelName}::render`;
+    // Handler bumps version to trigger Vue reactivity when this instance updates
+    const renderHandler = (eventData) => {
+        const isRef = reactivityFn === ref;
+        const model = isRef ? wrapper.value : wrapper;
+        if (eventData.pk === model[pkField]) {
+            if (isRef) {
+                wrapper.value.touch();
+            }
+            else {
+                wrapper.touch();
+            }
+        }
+    };
+    // Subscribe to model events indefinitely
+    modelEventEmitter.on(eventName, renderHandler);
+    return wrapper;
+}
+/**
+ * Adapts a queryset to a Vue reactive object and sets up event handling for queryset updates
+ *
+ * @param {Object} liveQuerySet - A LiveQueryset instance
+ * @param {Function} [reactivityFn=reactive] - Which Vue reactivity function to use (reactive or ref)
+ * @returns {import('vue').Reactive|import('vue').Ref} The reactive queryset
+ */
+export function QuerySetAdaptor(liveQuerySet, reactivityFn = reactive) {
+    const queryset = liveQuerySet?.queryset;
+    const modelName = queryset?.ModelClass?.modelName;
+    const configKey = queryset?.ModelClass?.configKey;
+    if (isNil(queryset) || isNil(modelName)) {
+        throw new Error(`liveQuerySet ${JSON.stringify(liveQuerySet)} had null qs: ${queryset} or model: ${modelName}`);
+    }
+    // Use the semantic key if available
+    const cacheKey = queryset.semanticKey;
+    // Check the cache first
+    if (cacheKey && wrappedQuerysetCache.has(cacheKey)) {
+        return wrappedQuerysetCache.get(cacheKey);
+    }
+    const querysetAst = queryset.build();
+    // Make the queryset reactive using the specified function
+    const wrapper = reactivityFn([...liveQuerySet]);
+    wrapper.original = liveQuerySet;
+    const eventName = `${configKey}::${modelName}::queryset::render`;
+    // Handler bumps version to trigger Vue reactivity when this queryset updates
+    const renderHandler = (eventData) => {
+        if (eventData && eventData.ast && isEqual(querysetAst, eventData.ast)) {
+            if (reactivityFn === ref) {
+                wrapper.value = [...liveQuerySet];
+            }
+            else {
+                wrapper.splice(0, wrapper.length);
+                wrapper.push(...liveQuerySet);
+            }
+        }
+    };
+    // Subscribe to queryset events indefinitely
+    querysetEventEmitter.on(eventName, renderHandler);
+    /* Dont delete the innocuous looking queryset.length check. There is some weird interaction
+    with vue, where when we load an empty queryset from the cache, the reactivity completely breaks.
+    I wasted over 2 days on this bug, and it won't show up in the e2e tests because it just impacts the
+    vue reactivity. If this causes performance issues, and needs to be refactored. Make sure you understand
+    the vue reactivity interaction correctly and find a different way to fix the broken reactivity for empty querysets */
+    if (cacheKey && liveQuerySet && liveQuerySet.length > 0) {
+        wrappedQuerysetCache.set(cacheKey, wrapper);
+    }
+    return wrapper;
+}
+export function MetricAdaptor(metric) {
+    const queryset = metric.queryset;
+    const modelName = queryset?.ModelClass?.modelName;
+    const configKey = queryset?.ModelClass?.configKey;
+    const querysetAst = queryset.build();
+    // Create a cache key based on metric properties
+    // This combines model, metric type, field, and the queryset AST hash to ensure uniqueness
+    const cacheKey = `${configKey}::${modelName}::${metric.metricType}::${metric.field}::${hash(querysetAst)}`;
+    // Check the cache first
+    if (cacheKey && wrappedMetricCache.has(cacheKey)) {
+        return wrappedMetricCache.get(cacheKey);
+    }
+    // Create a reactive reference with the initial value
+    const wrapper = ref(metric.value);
+    wrapper.original = metric;
+    // Single handler for metric render events
+    const metricRenderHandler = (eventData) => {
+        // Only update if this event is for our metric
+        if (eventData.metricType === metric.metricType &&
+            eventData.ModelClass === metric.queryset.ModelClass &&
+            eventData.field === metric.field &&
+            eventData.ast === hash(querysetAst) &&
+            eventData.valueChanged === true) {
+            // Update the wrapper value with the latest metric value
+            wrapper.value = metric.value;
+        }
+    };
+    // Only listen for metric render events
+    metricEventEmitter.on('metric::render', metricRenderHandler);
+    // Store in cache
+    if (cacheKey) {
+        wrappedMetricCache.set(cacheKey, wrapper);
+    }
+    return wrapper;
+}

package/dist/cli/commands/syncModels.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Main exported function to generate schema.
+ * @param {GenerateArgs} args
+ * @returns {Promise<void>}
+ */
+export function generateSchema(args: GenerateArgs): Promise<void>;
+/**
+ * // Additional arguments for generation if needed.
+ */
+export type GenerateArgs = Object;
+export type SchemaProperty = {
+    type: string;
+    format?: string | undefined;
+    items?: SchemaProperty | undefined;
+    properties?: {
+        [x: string]: SchemaProperty;
+    } | undefined;
+    required?: string[] | undefined;
+    enum?: string[] | undefined;
+    description?: string | undefined;
+    nullable?: boolean | undefined;
+    default?: any;
+    ref?: string | undefined;
+};
+export type RelationshipField = {
+    /**
+     * - Name of the relationship field
+     */
+    field: string;
+    /**
+     * - The class name of the related model
+     */
+    ModelClass: string;
+    /**
+     * - Type of relationship (e.g., "many-to-many", "foreign-key")
+     */
+    relationshipType: string;
+};
+export type RelationshipData = {
+    type: string;
+    /**
+     * - e.g. "django_app.deepmodellevel1"
+     */
+    model: string;
+    /**
+     * - e.g. "DeepModelLevel1"
+     */
+    class_name: string;
+    primary_key_field: string;
+};
+export type SchemaDefinition = {
+    type: string;
+    properties: {
+        [x: string]: SchemaProperty;
+    };
+    required?: string[] | undefined;
+    description?: string | undefined;
+    definitions?: {
+        [x: string]: SchemaDefinition;
+    } | undefined;
+    model_name: string;
+    class_name: string;
+    primary_key_field?: string | undefined;
+    relationships?: {
+        [x: string]: RelationshipData;
+    } | undefined;
+};
+export type PropertyDefinition = {
+    name: string;
+    type: string;
+    required: boolean;
+    defaultValue: string;
+    isRelationship?: boolean | undefined;
+    relationshipClassName?: string | undefined;
+    isArrayRelationship?: boolean | undefined;
+    relationshipPrimaryKeyField?: string | undefined;
+    isString?: boolean | undefined;
+    isNumber?: boolean | undefined;
+    isBoolean?: boolean | undefined;
+    isDate?: boolean | undefined;
+    isPrimaryKey?: boolean | undefined;
+};
+export type TemplateData = {
+    /**
+     * - Dynamic module path for imports.
+     */
+    modulePath: string;
+    /**
+     * - Exported full model class name (from schema.class_name).
+     */
+    className: string;
+    /**
+     * - Full model fields interface name (e.g. DeepModelLevel1Fields).
+     */
+    interfaceName: string;
+    /**
+     * - Raw schema.model_name (including app label path).
+     */
+    modelName: string;
+    properties: PropertyDefinition[];
+    /**
+     * - List of relationship fields for the model
+     */
+    relationshipFields: RelationshipField[];
+    description?: string | undefined;
+    definitions?: string[] | undefined;
+    /**
+     * - For JS generation: full class imports.
+     */
+    jsImports?: string[] | undefined;
+    /**
+     * - For TS generation: type imports (Fields).
+     */
+    tsImports?: string[] | undefined;
+    /**
+     * - The backend config key.
+     */
+    configKey: string;
+    /**
+     * - Primary key field from schema.
+     */
+    primaryKeyField: string;
+};
+export type BackendConfig = {
+    NAME: string;
+    API_URL: string;
+    GENERATED_TYPES_DIR: string;
+};
+export type SelectedModel = {
+    backend: BackendConfig;
+    model: string;
+};