@statezero/core 0.1.73 → 0.1.75

package/dist/actions/django_app/send-notification.js

@@ -0,0 +1,78 @@
+/**
+ * This file was auto-generated. Do not make direct changes to the file.
+ * Action: Send Notification
+ * App: django_app
+ */
+import axios from 'axios';
+import { z } from 'zod';
+import { configInstance, parseStateZeroError } from '../../../src';
+/**
+ * Zod schema for the input of sendNotification.
+ * NOTE: This is an object schema for validating the data payload.
+ */
+export const sendNotificationInputSchema = z.object({ message: z.string().max(500),
+    recipients: z.array(z.any()),
+    priority: z.enum(["low", "high"]).optional().default("low") });
+/**
+ * Zod schema for the response of sendNotification.
+ */
+export const sendNotificationResponseSchema = z.object({ success: z.boolean(),
+    message_id: z.string(),
+    sent_to: z.number().int(),
+    queued_at: z.string().datetime({ message: "Invalid ISO 8601 datetime string" }) });
+/**
+ * Send notifications to multiple recipients
+ *
+ * @param string message - Notification message to send
+ * @param any[] recipients - List of email addresses to notify
+ * @param 'low' | 'high' priority - Notification priority level
+ * @param {Object} [axiosOverrides] - Allows overriding Axios request parameters.
+ * @returns {Promise<Object>} A promise that resolves with the action's result.
+ */
+export async function sendNotification(message, recipients, priority = "low", axiosOverrides = {}) {
+    // Construct the data payload from the function arguments
+    const payload = {
+        message,
+        recipients,
+        priority
+    };
+    const config = configInstance.getConfig();
+    const backend = config.backendConfigs['default'];
+    if (!backend) {
+        throw new Error(`No backend configuration found for key: default`);
+    }
+    const baseUrl = backend.API_URL.replace(/\/+$/, '');
+    const actionUrl = `${baseUrl}/actions/send_notification/`;
+    const headers = backend.getAuthHeaders ? backend.getAuthHeaders() : {};
+    try {
+        const response = await axios.post(actionUrl, payload, {
+            headers: { 'Content-Type': 'application/json', ...headers },
+            ...axiosOverrides,
+        });
+        return sendNotificationResponseSchema.parse(response.data);
+    }
+    catch (error) {
+        if (error instanceof z.ZodError) {
+            throw new Error(`Send Notification failed: Invalid response from server. Details: ${error.message}`);
+        }
+        if (error.response && error.response.data) {
+            const parsedError = parseStateZeroError(error.response.data);
+            if (Error.captureStackTrace) {
+                Error.captureStackTrace(parsedError, sendNotification);
+            }
+            throw parsedError;
+        }
+        else if (error.request) {
+            throw new Error(`Send Notification failed: No response received from server.`);
+        }
+        else {
+            throw new Error(`Send Notification failed: ${error.message}`);
+        }
+    }
+}
+export default sendNotification;
+sendNotification.actionName = 'send_notification';
+sendNotification.title = 'Send Notification';
+sendNotification.app = 'django_app';
+sendNotification.permissions = ['CanSendNotifications'];
+sendNotification.configKey = 'default';

package/dist/actions/index.d.ts

@@ -0,0 +1 @@
+export * from "./django_app";

package/dist/actions/index.js

@@ -0,0 +1 @@
+export * from './django_app';

package/dist/cli/commands/syncActions.js

@@ -200,11 +200,11 @@ import { z } from 'zod';
 import { AxiosRequestConfig } from 'axios';
 
 {{#if inputTsSchemaString}}
-export type {{functionName}}Input = { {{inputTsSchemaString}} };
+export type {{functionName}}Input = { {{{inputTsSchemaString}}} };
 {{/if}}
 
 {{#if responseTsSchemaString}}
-export type {{functionName}}Response = { {{responseTsSchemaString}} };
+export type {{functionName}}Response = { {{{responseTsSchemaString}}} };
 {{else}}
 export type {{functionName}}Response = any;
 {{/if}}
@@ -243,8 +243,10 @@ const dtsActionTemplate = Handlebars.compile(TS_ACTION_DECLARATION_TEMPLATE);
 // ================================================================================================
 function generateZodSchemaForProperty(prop) {
     let zodString;
-    if (prop.choices && prop.choices.length > 0) {
-        zodString = `z.enum(${JSON.stringify(prop.choices)})`;
+    if (prop.choices && Object.keys(prop.choices).length > 0) {
+        // Extract just the keys (values) from the choices dict
+        const choiceValues = Object.keys(prop.choices);
+        zodString = `z.enum(${JSON.stringify(choiceValues)})`;
     }
     else {
         switch (prop.type) {
@@ -327,8 +329,8 @@ function generateZodSchemaForProperty(prop) {
     return zodString;
 }
 function generateTsTypeForProperty(prop) {
-    if (prop.choices && prop.choices.length > 0) {
-        return prop.choices
+    if (prop.choices && Object.keys(prop.choices).length > 0) {
+        return Object.keys(prop.choices)
             .map((c) => `'${String(c).replace(/'/g, "\\'")}'`)
             .join(" | ");
     }
@@ -384,7 +386,8 @@ function prepareActionTemplateData(modulePath, functionName, actionName, actionD
         const propertyStrings = propertyEntries
             .map(([name, prop]) => `${name}: ${generateTsTypeForProperty(prop)}`)
             .join(", ");
-        return propertyStrings;
+        // Wrap in SafeString to prevent Handlebars from escaping quotes
+        return new Handlebars.SafeString(propertyStrings);
     };
     const inputSchemaString = processProperties(inputProps);
     const responseSchemaString = processProperties(responseProps);
@@ -436,13 +439,16 @@ function prepareActionTemplateData(modulePath, functionName, actionName, actionD
 }
 async function generateActionFile(backend, actionName, actionDefinition) {
     const functionName = _.camelCase(actionName);
-    // Apply the same logic as syncModels.js
     const modulePath = process.env.NODE_ENV === "test" ? "../../../src" : "@statezero/core";
     const appName = (actionDefinition.app || "general").toLowerCase();
     const outDir = path.join(backend.GENERATED_ACTIONS_DIR, appName);
     await fs.mkdir(outDir, { recursive: true });
     const templateData = prepareActionTemplateData(modulePath, functionName, actionName, actionDefinition, backend.NAME);
     const fileName = _.kebabCase(actionName);
+    // Write the raw schema file (like models do)
+    const schemaFilePath = path.join(outDir, `${fileName}.schema.json`);
+    await fs.writeFile(schemaFilePath, JSON.stringify(actionDefinition, null, 2));
+    // Write JS and TS files
     const jsFilePath = path.join(outDir, `${fileName}.js`);
     await fs.writeFile(jsFilePath, jsActionTemplate(templateData));
     const dtsFilePath = path.join(outDir, `${fileName}.d.ts`);
@@ -461,6 +467,7 @@ async function generateActionFile(backend, actionName, actionDefinition) {
 }
 async function generateActionRegistry(generatedFiles, backendConfigs) {
     const registryByBackend = {};
+    const schemasByBackend = {};
     const allImports = new Set();
     for (const file of generatedFiles) {
         const backendKey = file.backend;
@@ -469,6 +476,7 @@ async function generateActionRegistry(generatedFiles, backendConfigs) {
         registryByBackend[backendKey] = registryByBackend[backendKey] || {
             actions: {},
         };
+        schemasByBackend[backendKey] = schemasByBackend[backendKey] || {};
         const functionName = file.functionName;
         const actionsDir = backendConfigs[backendKey].GENERATED_ACTIONS_DIR;
         const importPath = path
@@ -477,12 +485,19 @@ async function generateActionRegistry(generatedFiles, backendConfigs) {
         const importStatement = `import { ${functionName} } from './${importPath}';`;
         allImports.add(importStatement);
         registryByBackend[backendKey].actions[file.action] = functionName;
+        // Store schema path for getSchema function
+        const schemaPath = `./${importPath.replace(/\.js$/, '')}.schema.json`;
+        schemasByBackend[backendKey][file.action] = schemaPath;
     }
     let registryContent = `/**
  * This file was auto-generated. Do not make direct changes to the file.
  * It provides a registry of all generated actions.
- */\n\n`;
+ */
+
+`;
     registryContent += Array.from(allImports).sort().join("\n") + "\n\n";
+    // Add schema paths constant
+    registryContent += `const SCHEMA_PATHS = ${JSON.stringify(schemasByBackend, null, 2)};\n\n`;
     registryContent += `export const ACTION_REGISTRY = {\n`;
     Object.entries(registryByBackend).forEach(([backendKey, data], index, arr) => {
         registryContent += `  '${backendKey}': {\n`;
@@ -493,14 +508,43 @@ async function generateActionRegistry(generatedFiles, backendConfigs) {
         registryContent += `  }${index < arr.length - 1 ? "," : ""}\n`;
     });
     registryContent += `};\n\n`;
-    registryContent += `export function getAction(actionName, configKey) {
+    registryContent += `/**
+ * Get an action function by name and config key
+ * @param {string} actionName - The name of the action
+ * @param {string} configKey - The backend config key
+ * @returns {Function|null} The action function or null if not found
+ */
+export function getAction(actionName, configKey) {
   const action = ACTION_REGISTRY[configKey]?.[actionName];
   if (!action) {
     console.warn(\`Action '\${actionName}' not found for config key '\${configKey}'.\`);
     return null;
   }
   return action;
-}\n`;
+}
+
+/**
+ * Get the full schema for an action by loading its schema file
+ * @param {string} actionName - The name of the action
+ * @param {string} configKey - The backend config key
+ * @returns {Promise<Object|null>} The action schema or null if not found
+ */
+export async function getSchema(actionName, configKey) {
+  const schemaPath = SCHEMA_PATHS[configKey]?.[actionName];
+  if (!schemaPath) {
+    console.warn(\`Schema for action '\${actionName}' not found for config key '\${configKey}'.\`);
+    return null;
+  }
+  
+  try {
+    const schema = await import(schemaPath, { assert: { type: 'json' } });
+    return schema.default || schema;
+  } catch (error) {
+    console.error(\`Error loading schema for action '\${actionName}':\`, error);
+    return null;
+  }
+}
+`;
     const registryFilePath = path.join(process.cwd(), "action-registry.js");
     await fs.writeFile(registryFilePath, registryContent);
     console.log(`\n✨ Generated action registry at ${registryFilePath}`);
@@ -560,7 +604,6 @@ async function main() {
     });
     const backendActions = await Promise.all(fetchPromises);
     const choices = [];
-    // Reverted to group choices by backend for the CLI prompt
     for (const { backend, actions } of backendActions) {
         const actionNames = Object.keys(actions);
         if (actionNames.length > 0) {

package/dist/core/eventReceivers.d.ts

@@ -71,8 +71,8 @@ export class PusherEventReceiver {
     configKey: string;
     connectionTimeoutId: NodeJS.Timeout;
     pusherClient: Pusher;
-    formatChannelName: (ns: string) => string;
-    namespaceResolver: (modelName: string) => string;
+    formatChannelName: (arg0: string) => string;
+    namespaceResolver: NamespaceResolver;
     channels: Map<any, any>;
     eventHandlers: Set<any>;
     /**

package/dist/models/django_app/comprehensivemodel.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Model-specific QuerySet implementation
+ */
+export class ComprehensiveModelQuerySet extends QuerySet<any> {
+    constructor(ModelClass: ModelConstructor, config?: {
+        nodes?: QueryNode[] | undefined;
+        orderBy?: {
+            field: string;
+            direction: "asc" | "desc";
+        }[] | undefined;
+        fields?: Set<string> | undefined;
+        aggregations?: Aggregation[] | undefined;
+        initialQueryset?: string | undefined;
+        serializerOptions?: SerializerOptions;
+        materialized?: boolean | undefined;
+    } | undefined, parent?: null);
+}
+/**
+ * Model-specific Manager implementation
+ */
+export class ComprehensiveModelManager extends Manager {
+    constructor(ModelClass: any);
+}
+/**
+ * Implementation of the ComprehensiveModel model
+ */
+export class ComprehensiveModel extends Model {
+    static configKey: string;
+    static modelName: string;
+    static primaryKeyField: string;
+    static objects: ComprehensiveModelManager;
+    static fields: string[];
+    static schema: any;
+    static relationshipFields: Map<string, {
+        ModelClass: () => Function | null;
+        relationshipType: string;
+    }>;
+    constructor(data: any);
+    /**
+     * Define property getters and setters for all model fields
+     * @private
+     */
+    private _defineProperties;
+}
+import { QuerySet } from '../../../src';
+import { Manager } from '../../../src';
+import { Model } from '../../../src';

package/dist/models/django_app/comprehensivemodel.js

@@ -0,0 +1,63 @@
+/**
+ * This file was auto-generated. Do not make direct changes to the file.
+ */
+import { Model, Manager, QuerySet, getModelClass } from '../../../src';
+import { wrapReactiveModel } from '../../../src';
+import schemaData from './comprehensivemodel.schema.json';
+/**
+ * Model-specific QuerySet implementation
+ */
+export class ComprehensiveModelQuerySet extends QuerySet {
+}
+/**
+ * Model-specific Manager implementation
+ */
+export class ComprehensiveModelManager extends Manager {
+    constructor(ModelClass) {
+        super(ModelClass, ComprehensiveModelQuerySet);
+    }
+    newQuerySet() {
+        return new ComprehensiveModelQuerySet(this.ModelClass);
+    }
+}
+/**
+ * Implementation of the ComprehensiveModel model
+ */
+export class ComprehensiveModel extends Model {
+    constructor(data) {
+        ComprehensiveModel.validateFields(data);
+        super(data);
+        // Define getters and setters for all fields
+        this._defineProperties();
+        return wrapReactiveModel(this);
+    }
+    /**
+     * Define property getters and setters for all model fields
+     * @private
+     */
+    _defineProperties() {
+        // For each field, define a property that gets/sets from internal storage
+        ComprehensiveModel.fields.forEach(field => {
+            Object.defineProperty(this, field, {
+                get: function () {
+                    return this.getField(field);
+                },
+                set: function (value) {
+                    this.setField(field, value);
+                },
+                enumerable: true, // Make sure fields are enumerable for serialization
+                configurable: true
+            });
+        });
+    }
+}
+// Bind this model to its backend
+ComprehensiveModel.configKey = 'default';
+ComprehensiveModel.modelName = 'django_app.comprehensivemodel';
+ComprehensiveModel.primaryKeyField = 'id';
+ComprehensiveModel.objects = new ComprehensiveModelManager(ComprehensiveModel);
+ComprehensiveModel.fields = ['id', 'char_field', 'text_field', 'int_field', 'bool_field', 'datetime_field', 'decimal_field', 'json_field', 'money_field_currency', 'money_field', 'related'];
+ComprehensiveModel.schema = schemaData;
+ComprehensiveModel.relationshipFields = new Map([
+    ['related', { 'ModelClass': () => getModelClass('django_app.deepmodellevel1', 'default'), 'relationshipType': 'foreign-key' }]
+]);

package/dist/models/django_app/custompkmodel.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Model-specific QuerySet implementation
+ */
+export class CustomPKModelQuerySet extends QuerySet<any> {
+    constructor(ModelClass: ModelConstructor, config?: {
+        nodes?: QueryNode[] | undefined;
+        orderBy?: {
+            field: string;
+            direction: "asc" | "desc";
+        }[] | undefined;
+        fields?: Set<string> | undefined;
+        aggregations?: Aggregation[] | undefined;
+        initialQueryset?: string | undefined;
+        serializerOptions?: SerializerOptions;
+        materialized?: boolean | undefined;
+    } | undefined, parent?: null);
+}
+/**
+ * Model-specific Manager implementation
+ */
+export class CustomPKModelManager extends Manager {
+    constructor(ModelClass: any);
+}
+/**
+ * Implementation of the CustomPKModel model
+ */
+export class CustomPKModel extends Model {
+    static configKey: string;
+    static modelName: string;
+    static primaryKeyField: string;
+    static objects: CustomPKModelManager;
+    static fields: string[];
+    static schema: any;
+    static relationshipFields: Map<any, any>;
+    constructor(data: any);
+    /**
+     * Define property getters and setters for all model fields
+     * @private
+     */
+    private _defineProperties;
+}
+import { QuerySet } from '../../../src';
+import { Manager } from '../../../src';
+import { Model } from '../../../src';

package/dist/models/django_app/custompkmodel.js

@@ -0,0 +1,61 @@
+/**
+ * This file was auto-generated. Do not make direct changes to the file.
+ */
+import { Model, Manager, QuerySet, getModelClass } from '../../../src';
+import { wrapReactiveModel } from '../../../src';
+import schemaData from './custompkmodel.schema.json';
+/**
+ * Model-specific QuerySet implementation
+ */
+export class CustomPKModelQuerySet extends QuerySet {
+}
+/**
+ * Model-specific Manager implementation
+ */
+export class CustomPKModelManager extends Manager {
+    constructor(ModelClass) {
+        super(ModelClass, CustomPKModelQuerySet);
+    }
+    newQuerySet() {
+        return new CustomPKModelQuerySet(this.ModelClass);
+    }
+}
+/**
+ * Implementation of the CustomPKModel model
+ */
+export class CustomPKModel extends Model {
+    constructor(data) {
+        CustomPKModel.validateFields(data);
+        super(data);
+        // Define getters and setters for all fields
+        this._defineProperties();
+        return wrapReactiveModel(this);
+    }
+    /**
+     * Define property getters and setters for all model fields
+     * @private
+     */
+    _defineProperties() {
+        // For each field, define a property that gets/sets from internal storage
+        CustomPKModel.fields.forEach(field => {
+            Object.defineProperty(this, field, {
+                get: function () {
+                    return this.getField(field);
+                },
+                set: function (value) {
+                    this.setField(field, value);
+                },
+                enumerable: true, // Make sure fields are enumerable for serialization
+                configurable: true
+            });
+        });
+    }
+}
+// Bind this model to its backend
+CustomPKModel.configKey = 'default';
+CustomPKModel.modelName = 'django_app.custompkmodel';
+CustomPKModel.primaryKeyField = 'custom_pk';
+CustomPKModel.objects = new CustomPKModelManager(CustomPKModel);
+CustomPKModel.fields = ['custom_pk', 'name'];
+CustomPKModel.schema = schemaData;
+CustomPKModel.relationshipFields = new Map([]);

package/dist/models/django_app/deepmodellevel1.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Model-specific QuerySet implementation
+ */
+export class DeepModelLevel1QuerySet extends QuerySet<any> {
+    constructor(ModelClass: ModelConstructor, config?: {
+        nodes?: QueryNode[] | undefined;
+        orderBy?: {
+            field: string;
+            direction: "asc" | "desc";
+        }[] | undefined;
+        fields?: Set<string> | undefined;
+        aggregations?: Aggregation[] | undefined;
+        initialQueryset?: string | undefined;
+        serializerOptions?: SerializerOptions;
+        materialized?: boolean | undefined;
+    } | undefined, parent?: null);
+}
+/**
+ * Model-specific Manager implementation
+ */
+export class DeepModelLevel1Manager extends Manager {
+    constructor(ModelClass: any);
+}
+/**
+ * Implementation of the DeepModelLevel1 model
+ */
+export class DeepModelLevel1 extends Model {
+    static configKey: string;
+    static modelName: string;
+    static primaryKeyField: string;
+    static objects: DeepModelLevel1Manager;
+    static fields: string[];
+    static schema: any;
+    static relationshipFields: Map<string, {
+        ModelClass: () => Function | null;
+        relationshipType: string;
+    }>;
+    constructor(data: any);
+    /**
+     * Define property getters and setters for all model fields
+     * @private
+     */
+    private _defineProperties;
+}
+import { QuerySet } from '../../../src';
+import { Manager } from '../../../src';
+import { Model } from '../../../src';

package/dist/models/django_app/deepmodellevel1.js

@@ -0,0 +1,64 @@
+/**
+ * This file was auto-generated. Do not make direct changes to the file.
+ */
+import { Model, Manager, QuerySet, getModelClass } from '../../../src';
+import { wrapReactiveModel } from '../../../src';
+import schemaData from './deepmodellevel1.schema.json';
+/**
+ * Model-specific QuerySet implementation
+ */
+export class DeepModelLevel1QuerySet extends QuerySet {
+}
+/**
+ * Model-specific Manager implementation
+ */
+export class DeepModelLevel1Manager extends Manager {
+    constructor(ModelClass) {
+        super(ModelClass, DeepModelLevel1QuerySet);
+    }
+    newQuerySet() {
+        return new DeepModelLevel1QuerySet(this.ModelClass);
+    }
+}
+/**
+ * Implementation of the DeepModelLevel1 model
+ */
+export class DeepModelLevel1 extends Model {
+    constructor(data) {
+        DeepModelLevel1.validateFields(data);
+        super(data);
+        // Define getters and setters for all fields
+        this._defineProperties();
+        return wrapReactiveModel(this);
+    }
+    /**
+     * Define property getters and setters for all model fields
+     * @private
+     */
+    _defineProperties() {
+        // For each field, define a property that gets/sets from internal storage
+        DeepModelLevel1.fields.forEach(field => {
+            Object.defineProperty(this, field, {
+                get: function () {
+                    return this.getField(field);
+                },
+                set: function (value) {
+                    this.setField(field, value);
+                },
+                enumerable: true, // Make sure fields are enumerable for serialization
+                configurable: true
+            });
+        });
+    }
+}
+// Bind this model to its backend
+DeepModelLevel1.configKey = 'default';
+DeepModelLevel1.modelName = 'django_app.deepmodellevel1';
+DeepModelLevel1.primaryKeyField = 'id';
+DeepModelLevel1.objects = new DeepModelLevel1Manager(DeepModelLevel1);
+DeepModelLevel1.fields = ['id', 'name', 'level2', 'comprehensive_models'];
+DeepModelLevel1.schema = schemaData;
+DeepModelLevel1.relationshipFields = new Map([
+    ['level2', { 'ModelClass': () => getModelClass('django_app.deepmodellevel2', 'default'), 'relationshipType': 'foreign-key' }],
+    ['comprehensive_models', { 'ModelClass': () => getModelClass('django_app.comprehensivemodel', 'default'), 'relationshipType': 'many-to-many' }]
+]);

package/dist/models/django_app/deepmodellevel2.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Model-specific QuerySet implementation
+ */
+export class DeepModelLevel2QuerySet extends QuerySet<any> {
+    constructor(ModelClass: ModelConstructor, config?: {
+        nodes?: QueryNode[] | undefined;
+        orderBy?: {
+            field: string;
+            direction: "asc" | "desc";
+        }[] | undefined;
+        fields?: Set<string> | undefined;
+        aggregations?: Aggregation[] | undefined;
+        initialQueryset?: string | undefined;
+        serializerOptions?: SerializerOptions;
+        materialized?: boolean | undefined;
+    } | undefined, parent?: null);
+}
+/**
+ * Model-specific Manager implementation
+ */
+export class DeepModelLevel2Manager extends Manager {
+    constructor(ModelClass: any);
+}
+/**
+ * Implementation of the DeepModelLevel2 model
+ */
+export class DeepModelLevel2 extends Model {
+    static configKey: string;
+    static modelName: string;
+    static primaryKeyField: string;
+    static objects: DeepModelLevel2Manager;
+    static fields: string[];
+    static schema: any;
+    static relationshipFields: Map<string, {
+        ModelClass: () => Function | null;
+        relationshipType: string;
+    }>;
+    constructor(data: any);
+    /**
+     * Define property getters and setters for all model fields
+     * @private
+     */
+    private _defineProperties;
+}
+import { QuerySet } from '../../../src';
+import { Manager } from '../../../src';
+import { Model } from '../../../src';