@statezero/core 0.2.22 → 0.2.25

package/dist/actions/default/django_app/send-notification.d.ts

@@ -0,0 +1,55 @@
+/**
+ * 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 function sendNotification(message: any, recipients: any, priority?: string, axiosOverrides?: Object): Promise<Object>;
+export namespace sendNotification {
+    let actionName: string;
+    let title: string;
+    let app: string;
+    let permissions: string[];
+    let configKey: string;
+}
+/**
+ * Zod schema for the input of sendNotification.
+ * NOTE: This is an object schema for validating the data payload.
+ */
+export const sendNotificationInputSchema: z.ZodObject<{
+    message: z.ZodString;
+    recipients: z.ZodArray<z.ZodAny, "many">;
+    priority: z.ZodDefault<z.ZodOptional<z.ZodEnum<["low", "high"]>>>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    priority: "low" | "high";
+    recipients: any[];
+}, {
+    message: string;
+    recipients: any[];
+    priority?: "low" | "high" | undefined;
+}>;
+/**
+ * Zod schema for the response of sendNotification.
+ */
+export const sendNotificationResponseSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    message_id: z.ZodString;
+    sent_to: z.ZodNumber;
+    queued_at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    message_id: string;
+    sent_to: number;
+    queued_at: string;
+}, {
+    success: boolean;
+    message_id: string;
+    sent_to: number;
+    queued_at: string;
+}>;
+export default sendNotification;
+import { z } from 'zod';

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

@@ -0,0 +1,81 @@
+/**
+ * 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, serializeActionPayload } from '../../../../src';
+import actionSchema from './send-notification.schema.json' assert { type: 'json' };
+/**
+ * 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 rawPayload = {
+        message,
+        recipients,
+        priority
+    };
+    // Serialize payload - handles model instances (extracts PK), files, dates, etc.
+    const payload = serializeActionPayload(rawPayload, actionSchema.input_properties);
+    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/default/django_app/send-notification.schema.json

@@ -0,0 +1,175 @@
+{
+    "action_name": "send_notification",
+    "app": "django_app",
+    "title": "Send Notification",
+    "docstring": "Send notifications to multiple recipients",
+    "class_name": "SendNotification",
+    "input_properties": {
+        "message": {
+            "type": "string",
+            "title": "Message",
+            "required": true,
+            "description": "Notification message to send",
+            "nullable": false,
+            "format": null,
+            "max_length": 500,
+            "choices": null,
+            "default": null,
+            "validators": [],
+            "max_digits": null,
+            "decimal_places": null,
+            "read_only": false,
+            "ref": null
+        },
+        "recipients": {
+            "type": "array",
+            "title": "Recipients",
+            "required": true,
+            "description": "List of email addresses to notify",
+            "nullable": false,
+            "format": null,
+            "max_length": null,
+            "choices": null,
+            "default": null,
+            "validators": [],
+            "max_digits": null,
+            "decimal_places": null,
+            "read_only": false,
+            "ref": null
+        },
+        "priority": {
+            "type": "string",
+            "title": "Priority",
+            "required": false,
+            "description": "Notification priority level",
+            "nullable": false,
+            "format": null,
+            "max_length": null,
+            "choices": {
+                "low": "Low",
+                "high": "High"
+            },
+            "default": "low",
+            "validators": [],
+            "max_digits": null,
+            "decimal_places": null,
+            "read_only": false,
+            "ref": null
+        }
+    },
+    "response_properties": {
+        "success": {
+            "type": "boolean",
+            "title": "Success",
+            "required": true,
+            "description": null,
+            "nullable": false,
+            "format": null,
+            "max_length": null,
+            "choices": null,
+            "default": null,
+            "validators": [],
+            "max_digits": null,
+            "decimal_places": null,
+            "read_only": false,
+            "ref": null
+        },
+        "message_id": {
+            "type": "string",
+            "title": "Message id",
+            "required": true,
+            "description": null,
+            "nullable": false,
+            "format": null,
+            "max_length": null,
+            "choices": null,
+            "default": null,
+            "validators": [],
+            "max_digits": null,
+            "decimal_places": null,
+            "read_only": false,
+            "ref": null
+        },
+        "sent_to": {
+            "type": "integer",
+            "title": "Sent to",
+            "required": true,
+            "description": null,
+            "nullable": false,
+            "format": null,
+            "max_length": null,
+            "choices": null,
+            "default": null,
+            "validators": [],
+            "max_digits": null,
+            "decimal_places": null,
+            "read_only": false,
+            "ref": null
+        },
+        "queued_at": {
+            "type": "string",
+            "title": "Queued at",
+            "required": true,
+            "description": null,
+            "nullable": false,
+            "format": "date-time",
+            "max_length": null,
+            "choices": null,
+            "default": null,
+            "validators": [],
+            "max_digits": null,
+            "decimal_places": null,
+            "read_only": false,
+            "ref": null
+        }
+    },
+    "relationships": {},
+    "permissions": [
+        "CanSendNotifications"
+    ],
+    "display": {
+        "display_title": "Send Notifications",
+        "display_description": "Send notifications to multiple recipients with priority control",
+        "field_groups": [
+            {
+                "display_title": "Message Content",
+                "display_description": "The notification message and priority level",
+                "field_names": [
+                    "message",
+                    "priority"
+                ]
+            },
+            {
+                "display_title": "Recipients",
+                "display_description": "Email addresses to send notifications to",
+                "field_names": [
+                    "recipients"
+                ]
+            }
+        ],
+        "field_display_configs": [
+            {
+                "field_name": "message",
+                "display_component": "TextArea",
+                "filter_queryset": null,
+                "display_help_text": "Enter your notification message here (max 500 characters)",
+                "extra": null
+            },
+            {
+                "field_name": "priority",
+                "display_component": "RadioGroup",
+                "filter_queryset": null,
+                "display_help_text": "High priority notifications are processed first",
+                "extra": null
+            },
+            {
+                "field_name": "recipients",
+                "display_component": "EmailListInput",
+                "filter_queryset": null,
+                "display_help_text": "Add one or more email addresses",
+                "extra": null
+            }
+        ],
+        "extra": null
+    }
+}

package/dist/actions/default/index.d.ts

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

package/dist/actions/default/index.js

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

package/dist/actions/index.d.ts

@@ -0,0 +1 @@
+export * from "./default/index.js";

package/dist/actions/index.js

@@ -0,0 +1,5 @@
+/**
+ * This file was auto-generated. Do not make direct changes to the file.
+ * Re-exports from the 'default' backend for backwards compatibility.
+ */
+export * from './default/index.js';

package/dist/filtering/localFiltering.d.ts

@@ -7,14 +7,7 @@
  * @returns {string[]} Array of dot-notation paths, e.g. ['author.id','createdAt.year']
  */
 export function getRequiredFields(queryBuild: Object, ModelClass: Class): string[];
-/**
- * Pick out only the required fields from a (possibly nested) model object.
- *
- * @param {string[]} requiredPaths  – e.g. ['id','related.name','related.age']
- * @param {Object}   instance       – e.g. { id: 3, related: { name: 'bob', age: 12, foo: 'bar' } }
- * @returns {Object}                – e.g. { id: 3, related: { name: 'bob', age: 12 } }
- */
-export function pickRequiredFields(requiredPaths: string[], instance: Object): Object;
+export function pickRequiredFields(requiredPaths: any, instance: any): {};
 /**
  * Filter and order a collection of data objects according to a QuerySet's AST.
  * This combines getRequiredFields, pickRequiredFields, and processQuery in one function.

package/dist/filtering/localFiltering.js

@@ -99,6 +99,30 @@ function processFieldPath(fieldPath, value, ModelClass, options = {}) {
             const relationship = currentModel.relationshipFields.get(part);
             const relatedModel = relationship.ModelClass();
             const relationshipType = relationship.relationshipType;
+            // If this is not the last part and it's M2M, recursively process the remaining path
+            if (!isLastPart && relationshipType === 'many-to-many') {
+                // Build the remaining path including any lookup operators
+                const remainingFieldParts = fieldParts.slice(i + 1);
+                let fullRemainingPath = remainingFieldParts.join('__');
+                if (lookupChain.length > 0) {
+                    fullRemainingPath += '__' + lookupChain.join('__');
+                }
+                else if (lookup) {
+                    fullRemainingPath += '__' + lookup;
+                }
+                // Recursively process the remaining path with the related model
+                const innerResult = processFieldPath(fullRemainingPath, value, relatedModel, options);
+                // Build the required path for data picking (full dot-notation path)
+                const innerRequiredPath = innerResult.requiredPath || innerResult.field;
+                const requiredPath = `${part}.${innerRequiredPath}`;
+                // Wrap the inner result in $elemMatch for this M2M field
+                return {
+                    field: part,
+                    operator: { $elemMatch: { [innerResult.field]: innerResult.operator } },
+                    isM2M: true,
+                    requiredPath // Full path for data picking
+                };
+            }
             // Add this relationship field to the path
             processedPath.push(part);
             // If this is not the last part, update the current model to the related model
@@ -168,6 +192,10 @@ function processFieldPath(fieldPath, value, ModelClass, options = {}) {
         if (normalizedValue && typeof normalizedValue === 'object' && 'pk' in normalizedValue) {
             raw = normalizedValue.pk;
         }
+        // For M2M fields, use $elemMatch to check if any element's pk matches
+        if (isM2M) {
+            return { field: finalPath, operator: { $elemMatch: { pk: { $eq: raw } } }, isM2M: true };
+        }
         return { field: finalPath, operator: { $eq: raw } };
     }
     // Default to direct equality
@@ -217,18 +245,19 @@ function createOperatorFromLookup(field, lookup, value, isRelationship, ModelCla
         // For relationship fields with lookups, we need special handling
         if (lookup === 'isnull') {
             if (isM2M) {
-                // For M2M fields, isnull=True means null OR empty array, but not undefined because
-                // that can mean the field was not fetched so we can't be sure
+                // For M2M fields, isnull=True means null OR empty array
                 // isnull=False means has at least one item
-                // Use a custom function since sift doesn't support $or inside field operators
+                // Use document-level $where to check the array itself (not iterate elements)
+                const m2mField = field;
+                const checkEmpty = value;
                 return {
-                    field,
-                    operator: {
-                        $where: function (fieldValue) {
-                            const isEmpty = fieldValue === null ||
-                                (Array.isArray(fieldValue) && fieldValue.length === 0);
-                            return value ? isEmpty : !isEmpty;
-                        }
+                    field: '$where', // document-level operator
+                    requiredPath: field, // need the M2M field itself for data picking
+                    operator: function (doc) {
+                        const fieldValue = doc[m2mField];
+                        const isEmpty = fieldValue === null ||
+                            (Array.isArray(fieldValue) && fieldValue.length === 0);
+                        return checkEmpty ? isEmpty : !isEmpty;
                     }
                 };
             }
@@ -239,10 +268,17 @@ function createOperatorFromLookup(field, lookup, value, isRelationship, ModelCla
             };
         }
         else if (lookup === 'in') {
+            // For M2M, check if any element's pk is in the provided array
+            if (isM2M) {
+                return { field, operator: { $elemMatch: { pk: { $in: value } } }, isM2M: true };
+            }
             return { field, operator: { $in: value } };
         }
         else {
             // Default handling for relationship fields
+            if (isM2M) {
+                return { field, operator: { $elemMatch: { pk: { $eq: value } } }, isM2M: true };
+            }
             return { field, operator: { $eq: value } };
         }
     }
@@ -545,10 +581,11 @@ function createFilterWithDateOperations(criteria, ModelClass) {
 function convertToSiftCriteria(conditions, ModelClass) {
     const result = {};
     const datePartFilters = new Map(); // Map to collect date part filters by field
+    const m2mConditions = new Map(); // Map to collect M2M $elemMatch conditions by field
     for (const [key, value] of Object.entries(conditions)) {
         try {
             const processedResult = processFieldPath(key, value, ModelClass);
-            const { field, operator, isDatePart } = processedResult;
+            const { field, operator, isDatePart, isM2M } = processedResult;
             if (isDatePart) {
                 // Handle date part operators separately
                 if (!datePartFilters.has(field)) {
@@ -556,6 +593,13 @@ function convertToSiftCriteria(conditions, ModelClass) {
                 }
                 datePartFilters.get(field).push({ [field]: operator });
             }
+            else if (isM2M && operator.$elemMatch) {
+                // Collect M2M conditions to merge into single $elemMatch
+                if (!m2mConditions.has(field)) {
+                    m2mConditions.set(field, []);
+                }
+                m2mConditions.get(field).push(operator.$elemMatch);
+            }
             else {
                 // For regular operators, merge if we already have criteria for this field
                 if (result[field]) {
@@ -570,6 +614,17 @@ function convertToSiftCriteria(conditions, ModelClass) {
             throw new Error(`Failed to process field '${key}': ${error.message}`);
         }
     }
+    // Merge M2M conditions: all conditions on same M2M field go into single $elemMatch
+    // so the SAME related object must match ALL conditions
+    for (const [field, elemMatchConditions] of m2mConditions.entries()) {
+        if (elemMatchConditions.length === 1) {
+            result[field] = { $elemMatch: elemMatchConditions[0] };
+        }
+        else {
+            // Multiple conditions - wrap in $and so same element must match all
+            result[field] = { $elemMatch: { $and: elemMatchConditions } };
+        }
+    }
     // If we have date part filters, combine them with the result
     if (datePartFilters.size > 0) {
         const andConditions = [];
@@ -663,6 +718,9 @@ function convertFilterNodeToSiftCriteria(filterNode, ModelClass) {
             return null;
         if (childCriteria.length === 1)
             return childCriteria[0];
+        // Chained filters use $and at top level - this gives ANY/ANY semantics for M2M
+        // (each $elemMatch can be satisfied by different elements)
+        // This matches Django's chained .filter() behavior
         return { $and: childCriteria };
     }
     // For compound OR nodes
@@ -863,12 +921,24 @@ export function getRequiredFields(queryBuild, ModelClass) {
     function addPath(rawKey) {
         try {
             // We pass `null` as the value, since we only care about .field
-            const { field } = processFieldPath(rawKey, null, ModelClass);
-            paths.add(field);
+            const { field, isM2M, requiredPath } = processFieldPath(rawKey, null, ModelClass);
+            // Use requiredPath if available (for M2M traversal), otherwise use field
+            // For M2M fields at the end of a path (no requiredPath), we need the pk field
+            let finalPath;
+            if (requiredPath) {
+                finalPath = requiredPath;
+            }
+            else if (isM2M) {
+                finalPath = `${field}.pk`;
+            }
+            else {
+                finalPath = field;
+            }
+            paths.add(finalPath);
         }
         catch (err) {
-            // if a key doesn’t map, warn and skip it
-            console.warn(`getRequiredFields: couldn’t process "${rawKey}": ${err.message}`);
+            // if a key doesn't map, warn and skip it
+            console.warn(`getRequiredFields: couldn't process "${rawKey}": ${err.message}`);
         }
     }
     // Recursively walk your filter AST
@@ -917,42 +987,48 @@ export function getRequiredFields(queryBuild, ModelClass) {
  * @param {Object}   instance       – e.g. { id: 3, related: { name: 'bob', age: 12, foo: 'bar' } }
  * @returns {Object}                – e.g. { id: 3, related: { name: 'bob', age: 12 } }
  */
+/**
+ * Recursively sets a value in a result object following a path.
+ * Handles arrays (M2M fields) by mapping over each element.
+ */
+function setNestedValueRecursive(result, source, pathParts) {
+    if (source == null || pathParts.length === 0) {
+        return;
+    }
+    const [current, ...rest] = pathParts;
+    const sourceValue = source[current];
+    if (sourceValue === undefined) {
+        return;
+    }
+    if (rest.length === 0) {
+        // Last part - set the value directly, keeping M2M as full objects
+        result[current] = sourceValue;
+    }
+    else if (Array.isArray(sourceValue)) {
+        // M2M array with nested path - recursively extract from each element
+        if (!(current in result)) {
+            result[current] = [];
+        }
+        sourceValue.forEach((item, idx) => {
+            if (result[current][idx] === undefined) {
+                result[current][idx] = {};
+            }
+            setNestedValueRecursive(result[current][idx], item, rest);
+        });
+    }
+    else if (typeof sourceValue === 'object') {
+        // Regular nested object (FK)
+        if (!(current in result)) {
+            result[current] = {};
+        }
+        setNestedValueRecursive(result[current], sourceValue, rest);
+    }
+}
 export function pickRequiredFields(requiredPaths, instance) {
     const result = {};
     requiredPaths.forEach(path => {
         const parts = path.split('.');
-        // Traverse the source instance to get the value
-        let value = instance;
-        for (const key of parts) {
-            if (value == null || !(key in value)) {
-                value = undefined;
-                break;
-            }
-            value = value[key];
-        }
-        if (value === undefined) {
-            // skip missing
-            return;
-        }
-        // Convert M2M arrays from Model instances to PKs for comparison
-        // This handles the case where the live representation returns [Model1, Model2]
-        // but we need [pk1, pk2] for sift filtering
-        if (Array.isArray(value) && value.length > 0 && value[0]?.pk !== undefined) {
-            value = value.map(item => item.pk);
-        }
-        // Build nested structure in the result
-        let cursor = result;
-        parts.forEach((key, idx) => {
-            if (idx === parts.length - 1) {
-                cursor[key] = value;
-            }
-            else {
-                if (!(key in cursor)) {
-                    cursor[key] = {};
-                }
-                cursor = cursor[key];
-            }
-        });
+        setNestedValueRecursive(result, instance, parts);
     });
     return result;
 }

package/dist/flavours/django/dates.js

@@ -83,7 +83,10 @@ export class DateParsingHelpers {
         try {
             // Handle ISO format (Django's default)
             if (!dateFormat || dateFormat === 'iso-8601') {
-                return date.toISOString();
+                // For date-only fields, return just the date portion
+                return fieldFormat === 'date'
+                    ? date.toISOString().slice(0, 10)
+                    : date.toISOString();
             }
             // Handle supported Django formats
             const dateFnsFormat = this.SUPPORTED_FORMATS[dateFormat];

package/dist/flavours/django/serializers.js

@@ -75,9 +75,13 @@ export const dateFieldSerializer = {
             return value;
         // If it's a Date object, serialize it using DateParsingHelpers
         if (value instanceof Date) {
-            const { model, field } = context;
-            if (model?.schema) {
-                return DateParsingHelpers.serializeDate(value, field, model.schema);
+            const { model, field, fieldSchema } = context;
+            // Use model schema, or create minimal schema from fieldSchema (for actions)
+            const schema = model?.schema || (fieldSchema?.format && {
+                properties: { [field]: { format: fieldSchema.format } }
+            });
+            if (schema) {
+                return DateParsingHelpers.serializeDate(value, field, schema);
             }
             // Fallback if no schema context
             return value.toISOString();
@@ -214,7 +218,7 @@ export function serializeActionPayload(payload, inputProperties) {
         const typeSerializers = serializers[type];
         const serializer = typeSerializers?.[format];
         if (serializer) {
-            serializedPayload[field] = serializer.toInternal(value, { field });
+            serializedPayload[field] = serializer.toInternal(value, { field, fieldSchema });
         }
         else {
             serializedPayload[field] = value;