@statezero/core 0.2.38 → 0.2.40

package/dist/flavours/django/dates.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Date parsing utilities for handling Django style date formats
+ */
+export class DateParsingHelpers {
+    static SUPPORTED_FORMATS: {
+        'iso-8601': null;
+        '%Y-%m-%d': string;
+        '%Y-%m-%d %H:%M:%S': string;
+        '%d/%m/%Y': string;
+        '%m/%d/%Y': string;
+        '%Y/%m/%d': string;
+        '%d-%m-%Y': string;
+        '%m-%d-%Y': string;
+        '%B %d, %Y': string;
+        '%d %B %Y': string;
+    };
+    /**
+     * Parse a date value using Django's format settings
+     * @param {string|Date} value - The date value to parse
+     * @param {string} fieldName - Name of the field (for schema lookup)
+     * @param {Object} schema - The model schema containing format info
+     * @param {string} timezone - The backend timezone (defaults to 'UTC')
+     * @returns {Date|null} - Parsed Date object or null if invalid
+     */
+    static parseDate(value: string | Date, fieldName: string, schema: Object, timezone?: string): Date | null;
+    /**
+     * Serialize a date using the field's configured format
+     * @param {Date} date - The date to serialize
+     * @param {string} fieldName - Name of the field (for schema lookup)
+     * @param {Object} schema - The model schema containing format info
+     * @returns {string|null} - Formatted date string or null if invalid
+     */
+    static serializeDate(date: Date, fieldName: string, schema: Object): string | null;
+}

package/dist/flavours/django/dates.js

@@ -0,0 +1,113 @@
+import { format, parse, parseISO } from 'date-fns';
+import { DateTime } from 'luxon';
+/**
+ * Date parsing utilities for handling Django style date formats
+ */
+export class DateParsingHelpers {
+    /**
+     * Parse a date value using Django's format settings
+     * @param {string|Date} value - The date value to parse
+     * @param {string} fieldName - Name of the field (for schema lookup)
+     * @param {Object} schema - The model schema containing format info
+     * @param {string} timezone - The backend timezone (defaults to 'UTC')
+     * @returns {Date|null} - Parsed Date object or null if invalid
+     */
+    static parseDate(value, fieldName, schema, timezone = 'UTC') {
+        if (!value)
+            return null;
+        // If already a Date object, return as-is (it's already a specific instant in time)
+        if (value instanceof Date)
+            return value;
+        const fieldFormat = schema.properties[fieldName].format;
+        if (!["date", "date-time"].includes(fieldFormat)) {
+            throw new Error(`Only date and date-time fields can be processed to JS date objects. ${fieldName} has format ${fieldFormat}`);
+        }
+        // Get field-specific format from schema
+        const formatStrings = {
+            'date': schema.date_format,
+            'date-time': schema.datetime_format
+        };
+        const dateFormat = formatStrings[fieldFormat];
+        // Check if format is supported
+        if (dateFormat && !this.SUPPORTED_FORMATS.hasOwnProperty(dateFormat)) {
+            throw new Error(`Unsupported date format "${dateFormat}" for field ${fieldName}. Supported formats: ${Object.keys(this.SUPPORTED_FORMATS).join(', ')}`);
+        }
+        try {
+            // Handle ISO format (Django's default)
+            if (!dateFormat || dateFormat === 'iso-8601') {
+                // Parse the string in the server timezone using Luxon
+                // This ensures '2022-03-15' is interpreted as midnight in the server TZ, not browser TZ
+                const luxonDate = DateTime.fromISO(value, { zone: timezone });
+                if (!luxonDate.isValid) {
+                    console.error(`Failed to parse ISO date "${value}":`, luxonDate.invalidReason);
+                    return null;
+                }
+                return luxonDate.toJSDate();
+            }
+            // Handle supported Django formats
+            const dateFnsFormat = this.SUPPORTED_FORMATS[dateFormat];
+            // For non-ISO formats, use date-fns but we should still consider timezone
+            // For now, parse with date-fns and assume it's in the server timezone
+            return parse(value, dateFnsFormat, new Date());
+        }
+        catch (error) {
+            console.error(`Failed to parse date "${value}" with format "${dateFormat}"`, error);
+            return null;
+        }
+    }
+    /**
+     * Serialize a date using the field's configured format
+     * @param {Date} date - The date to serialize
+     * @param {string} fieldName - Name of the field (for schema lookup)
+     * @param {Object} schema - The model schema containing format info
+     * @returns {string|null} - Formatted date string or null if invalid
+     */
+    static serializeDate(date, fieldName, schema) {
+        if (!date || !(date instanceof Date) || isNaN(date.getTime())) {
+            return date;
+        }
+        const fieldFormat = schema.properties[fieldName].format;
+        if (!["date", "date-time"].includes(fieldFormat)) {
+            throw new Error(`Only date and date-time fields can be processed to JS date objects. ${fieldName} has format ${fieldFormat}`);
+        }
+        // Get field-specific format from schema
+        const formatStrings = {
+            'date': schema.date_format,
+            'date-time': schema.datetime_format
+        };
+        const dateFormat = formatStrings[fieldFormat];
+        // Check if format is supported
+        if (dateFormat && !this.SUPPORTED_FORMATS.hasOwnProperty(dateFormat)) {
+            throw new Error(`Unsupported date format "${dateFormat}" for field ${fieldName}. Supported formats: ${Object.keys(this.SUPPORTED_FORMATS).join(', ')}`);
+        }
+        try {
+            // Handle ISO format (Django's default)
+            if (!dateFormat || dateFormat === 'iso-8601') {
+                // 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];
+            return format(date, dateFnsFormat);
+        }
+        catch (error) {
+            console.error(`Failed to format date with format "${dateFormat}"`, error);
+            return date.toISOString(); // Fallback to ISO format
+        }
+    }
+}
+// Supported Django strftime formats and their date-fns equivalents
+DateParsingHelpers.SUPPORTED_FORMATS = {
+    'iso-8601': null, // Special case - use parseISO/toISOString
+    '%Y-%m-%d': 'yyyy-MM-dd', // 2024-12-31
+    '%Y-%m-%d %H:%M:%S': 'yyyy-MM-dd HH:mm:ss', // 2024-12-31 14:30:45
+    '%d/%m/%Y': 'dd/MM/yyyy', // 31/12/2024
+    '%m/%d/%Y': 'MM/dd/yyyy', // 12/31/2024
+    '%Y/%m/%d': 'yyyy/MM/dd', // 2024/12/31
+    '%d-%m-%Y': 'dd-MM-yyyy', // 31-12-2024
+    '%m-%d-%Y': 'MM-dd-yyyy', // 12-31-2024
+    '%B %d, %Y': 'MMMM dd, yyyy', // December 31, 2024
+    '%d %B %Y': 'dd MMMM yyyy', // 31 December 2024
+};

package/dist/flavours/django/errors.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Parses a JSON error response from the backend and returns an instance
+ * of the corresponding custom error.
+ *
+ * @param {IErrorResponse} errorResponse - The error response JSON.
+ * @returns {StateZeroError} An instance of a StateZeroError subclass.
+ */
+export function parseStateZeroError(errorResponse: IErrorResponse): StateZeroError;
+/**
+ * @typedef {Object} IErrorResponse
+ * @property {number} status - The HTTP status code.
+ * @property {string} type - The error type.
+ * @property {*} detail - The error details.
+ */
+/**
+ * @typedef {Object} IErrorDetail
+ * @property {string} message - The error message.
+ * @property {string} code - The error code.
+ */
+/**
+ * Base error class for StateZero errors.
+ */
+export class StateZeroError extends Error {
+    /**
+     * Creates a new StateZeroError.
+     *
+     * @param {string} message - The error message.
+     * @param {string} code - The error code.
+     * @param {IErrorDetail|Object|string} detail - The error details.
+     * @param {number} status - The HTTP status code.
+     */
+    constructor(message: string, code: string, detail: IErrorDetail | Object | string, status: number);
+    code: string;
+    detail: string | Object | IErrorDetail;
+    status: number;
+    /**
+     * Returns a full error message including the detail.
+     *
+     * @returns {string} The full error message with details
+     */
+    getFullMessage(): string;
+}
+/**
+ * Error class for validation errors.
+ */
+export class ValidationError extends StateZeroError {
+    /**
+     * Creates a new ValidationError.
+     *
+     * @param {IErrorDetail|Object|string} detail - The error details.
+     * @param {number} [status=400] - The HTTP status code.
+     */
+    constructor(detail: IErrorDetail | Object | string, status?: number);
+}
+/**
+ * Error class for "Does Not Exist" errors (renamed from NotFound).
+ */
+export class DoesNotExist extends StateZeroError {
+    /**
+     * Creates a new DoesNotExist error.
+     *
+     * @param {IErrorDetail|Object|string} [detail="Does not exist"] - The error details.
+     * @param {number} [status=404] - The HTTP status code.
+     */
+    constructor(detail?: IErrorDetail | Object | string, status?: number);
+}
+/**
+ * Error class for permission denied errors.
+ */
+export class PermissionDenied extends StateZeroError {
+    /**
+     * Creates a new PermissionDenied error.
+     *
+     * @param {IErrorDetail|Object|string} [detail="Permission denied"] - The error details.
+     * @param {number} [status=403] - The HTTP status code.
+     */
+    constructor(detail?: IErrorDetail | Object | string, status?: number);
+}
+/**
+ * Error class for multiple objects returned errors.
+ */
+export class MultipleObjectsReturned extends StateZeroError {
+    /**
+     * Creates a new MultipleObjectsReturned error.
+     *
+     * @param {IErrorDetail|Object|string} [detail="Multiple objects returned"] - The error details.
+     * @param {number} [status=500] - The HTTP status code.
+     */
+    constructor(detail?: IErrorDetail | Object | string, status?: number);
+}
+/**
+ * Error class for AST validation errors.
+ */
+export class ASTValidationError extends StateZeroError {
+    /**
+     * Creates a new ASTValidationError.
+     *
+     * @param {IErrorDetail|Object|string} detail - The error details.
+     * @param {number} [status=400] - The HTTP status code.
+     */
+    constructor(detail: IErrorDetail | Object | string, status?: number);
+}
+/**
+ * Error class for configuration errors.
+ */
+export class ConfigError extends StateZeroError {
+    /**
+     * Creates a new ConfigError.
+     *
+     * @param {IErrorDetail|Object|string} detail - The error details.
+     * @param {number} [status=500] - The HTTP status code.
+     */
+    constructor(detail: IErrorDetail | Object | string, status?: number);
+}
+export type IErrorResponse = {
+    /**
+     * - The HTTP status code.
+     */
+    status: number;
+    /**
+     * - The error type.
+     */
+    type: string;
+    /**
+     * - The error details.
+     */
+    detail: any;
+};
+export type IErrorDetail = {
+    /**
+     * - The error message.
+     */
+    message: string;
+    /**
+     * - The error code.
+     */
+    code: string;
+};

package/dist/flavours/django/errors.js

@@ -0,0 +1,195 @@
+import { emitError } from '../../errorHandler.js';
+/**
+ * @typedef {Object} IErrorResponse
+ * @property {number} status - The HTTP status code.
+ * @property {string} type - The error type.
+ * @property {*} detail - The error details.
+ */
+/**
+ * @typedef {Object} IErrorDetail
+ * @property {string} message - The error message.
+ * @property {string} code - The error code.
+ */
+/**
+ * Base error class for StateZero errors.
+ */
+export class StateZeroError extends Error {
+    /**
+     * Creates a new StateZeroError.
+     *
+     * @param {string} message - The error message.
+     * @param {string} code - The error code.
+     * @param {IErrorDetail|Object|string} detail - The error details.
+     * @param {number} status - The HTTP status code.
+     */
+    constructor(message, code, detail, status) {
+        super(message);
+        this.name = "StateZeroError";
+        this.code = code;
+        this.detail = detail;
+        this.status = status;
+        Object.setPrototypeOf(this, new.target.prototype);
+        emitError(this);
+    }
+    /**
+     * Returns a full error message including the detail.
+     *
+     * @returns {string} The full error message with details
+     */
+    getFullMessage() {
+        if (typeof this.detail === 'string') {
+            return `${this.message}: ${this.detail}`;
+        }
+        else if (this.detail && typeof this.detail === 'object') {
+            if (this.detail.message) {
+                return `${this.message}: ${this.detail.message}`;
+            }
+            else {
+                try {
+                    return `${this.message}: ${JSON.stringify(this.detail)}`;
+                }
+                catch (e) {
+                    return `${this.message}: [Complex detail object]`;
+                }
+            }
+        }
+        return this.message;
+    }
+}
+/**
+ * Error class for validation errors.
+ */
+export class ValidationError extends StateZeroError {
+    /**
+     * Creates a new ValidationError.
+     *
+     * @param {IErrorDetail|Object|string} detail - The error details.
+     * @param {number} [status=400] - The HTTP status code.
+     */
+    constructor(detail, status = 400) {
+        super("Validation error", "validation_error", detail, status);
+        this.name = "ValidationError";
+    }
+}
+/**
+ * Error class for "Does Not Exist" errors (renamed from NotFound).
+ */
+export class DoesNotExist extends StateZeroError {
+    /**
+     * Creates a new DoesNotExist error.
+     *
+     * @param {IErrorDetail|Object|string} [detail="Does not exist"] - The error details.
+     * @param {number} [status=404] - The HTTP status code.
+     */
+    constructor(detail = "Does not exist", status = 404) {
+        super("DoesNotExist", "does_not_exist", detail, status);
+        this.name = "DoesNotExist";
+    }
+}
+/**
+ * Error class for permission denied errors.
+ */
+export class PermissionDenied extends StateZeroError {
+    /**
+     * Creates a new PermissionDenied error.
+     *
+     * @param {IErrorDetail|Object|string} [detail="Permission denied"] - The error details.
+     * @param {number} [status=403] - The HTTP status code.
+     */
+    constructor(detail = "Permission denied", status = 403) {
+        super("Permission denied", "permission_denied", detail, status);
+        this.name = "PermissionDenied";
+    }
+}
+/**
+ * Error class for multiple objects returned errors.
+ */
+export class MultipleObjectsReturned extends StateZeroError {
+    /**
+     * Creates a new MultipleObjectsReturned error.
+     *
+     * @param {IErrorDetail|Object|string} [detail="Multiple objects returned"] - The error details.
+     * @param {number} [status=500] - The HTTP status code.
+     */
+    constructor(detail = "Multiple objects returned", status = 500) {
+        super("Multiple objects returned", "multiple_objects_returned", detail, status);
+        this.name = "MultipleObjectsReturned";
+    }
+}
+/**
+ * Error class for AST validation errors.
+ */
+export class ASTValidationError extends StateZeroError {
+    /**
+     * Creates a new ASTValidationError.
+     *
+     * @param {IErrorDetail|Object|string} detail - The error details.
+     * @param {number} [status=400] - The HTTP status code.
+     */
+    constructor(detail, status = 400) {
+        super("Query syntax error", "ast_validation_error", detail, status);
+        this.name = "ASTValidationError";
+    }
+}
+/**
+ * Error class for configuration errors.
+ */
+export class ConfigError extends StateZeroError {
+    /**
+     * Creates a new ConfigError.
+     *
+     * @param {IErrorDetail|Object|string} detail - The error details.
+     * @param {number} [status=500] - The HTTP status code.
+     */
+    constructor(detail, status = 500) {
+        super("Configuration error", "config_error", detail, status);
+        this.name = "ConfigError";
+    }
+}
+/**
+ * Parses a JSON error response from the backend and returns an instance
+ * of the corresponding custom error.
+ *
+ * @param {IErrorResponse} errorResponse - The error response JSON.
+ * @returns {StateZeroError} An instance of a StateZeroError subclass.
+ */
+export function parseStateZeroError(errorResponse) {
+    console.log(JSON.stringify(errorResponse));
+    const { status, type, detail } = errorResponse;
+    // Handle undefined type/status case (like in permission denied)
+    if (type === undefined && detail === 'Invalid token.') {
+        return new PermissionDenied(detail, 403);
+    }
+    switch (type) {
+        // Direct mappings
+        case "ValidationError":
+            return new ValidationError(detail, status);
+        case "NotFound":
+            return new DoesNotExist(detail, status);
+        case "MultipleObjectsReturned":
+            return new MultipleObjectsReturned(detail, status);
+        case "PermissionDenied":
+            return new PermissionDenied(detail, status);
+        case "ASTValidationError":
+            return new ASTValidationError(detail, status);
+        case "ConfigError":
+            return new ConfigError(detail, status);
+        // Django error types that map to our error classes
+        case "FieldError":
+            return new ValidationError(detail, status);
+        case "ValueError":
+            return new ValidationError(detail, status);
+        default:
+            // Fallback to status code based mapping
+            if (status === 400) {
+                return new ValidationError(detail, status);
+            }
+            else if (status === 403) {
+                return new PermissionDenied(detail, status);
+            }
+            else if (status === 404) {
+                return new DoesNotExist(detail, status);
+            }
+            return new StateZeroError("Unknown error", "unknown", detail, status);
+    }
+}

package/dist/flavours/django/f.d.ts

@@ -0,0 +1,6 @@
+export function F(expression: any): {
+    __f_expr: boolean;
+    original_expr: string;
+    ast: any;
+};
+export function evaluateExpression(expr: any, data: any): any;

package/dist/flavours/django/f.js

@@ -0,0 +1,91 @@
+import { ValidationError } from './errors.js';
+import * as math from 'mathjs';
+// Create a math instance
+const mathInstance = math.create();
+// Define the allowed functions that we want to keep
+const allowedFunctions = ['abs', 'round', 'floor', 'ceil', 'min', 'max'];
+// Define allowed operators
+const ALLOWED_OPERATORS = ['+', '-', '*', '/', '%', '^'];
+export function F(expression) {
+    if (typeof expression !== 'string' || !expression) {
+        throw new ValidationError('F expression requires a non-empty string');
+    }
+    try {
+        const node = math.parse(expression);
+        validateExpression(node);
+        return {
+            __f_expr: true,
+            original_expr: expression,
+            ast: node.toJSON()
+        };
+    }
+    catch (err) {
+        throw new ValidationError(`Invalid F expression: ${err.message}`);
+    }
+}
+function validateExpression(node) {
+    if (!node)
+        return;
+    if (node.type === 'OperatorNode') {
+        if (!ALLOWED_OPERATORS.includes(node.op)) {
+            throw new ValidationError(`Unsupported operator: ${node.op}`);
+        }
+        node.args.forEach(validateExpression);
+    }
+    else if (node.type === 'FunctionNode') {
+        if (!allowedFunctions.includes(node.name)) {
+            throw new ValidationError(`Function not allowed: ${node.name}`);
+        }
+        node.args.forEach(validateExpression);
+    }
+    else if (node.type === 'SymbolNode') {
+        if (!/^[a-zA-Z][a-zA-Z0-9_]*$/.test(node.name)) {
+            throw new ValidationError(`Invalid field name: ${node.name}`);
+        }
+    }
+    else if (node.type === 'ConstantNode') {
+        // Constants are fine
+    }
+    else if (node.type === 'ParenthesisNode') {
+        validateExpression(node.content);
+    }
+    else if (node.type === 'ConditionalNode') {
+        throw new ValidationError('Conditional expressions are not supported in F expressions');
+    }
+    else if (node.type === 'AssignmentNode') {
+        throw new ValidationError('Assignment expressions are not supported in F expressions');
+    }
+    else if (node.type === 'BlockNode') {
+        throw new ValidationError('Block expressions are not supported in F expressions');
+    }
+    else if (node.type === 'AccessorNode') {
+        throw new ValidationError('Accessor expressions are not supported in F expressions');
+    }
+    else if (node.type === 'IndexNode') {
+        throw new ValidationError('Index expressions are not supported in F expressions');
+    }
+    else if (node.type === 'RangeNode') {
+        throw new ValidationError('Range expressions are not supported in F expressions');
+    }
+    else if (node.type === 'ArrayNode') {
+        throw new ValidationError('Array expressions are not supported in F expressions');
+    }
+    else if (node.type === 'ObjectNode') {
+        throw new ValidationError('Object expressions are not supported in F expressions');
+    }
+    else {
+        throw new ValidationError(`Unsupported node type: ${node.type}`);
+    }
+}
+export function evaluateExpression(expr, data) {
+    if (!expr || !expr.__f_expr) {
+        return expr;
+    }
+    try {
+        return math.evaluate(expr.original_expr, data);
+    }
+    catch (err) {
+        console.warn(`Error evaluating F expression: ${err.message}`);
+        return null;
+    }
+}

package/dist/flavours/django/files.d.ts

@@ -0,0 +1,62 @@
+/**
+ * FileObject - A file wrapper that handles uploads to StateZero backend
+ */
+export class FileObject {
+    static configKey: string;
+    static MIN_CHUNK_SIZE: number;
+    constructor(file: any, options?: {});
+    name: any;
+    size: any;
+    type: any;
+    lastModified: number | null;
+    uploaded: boolean;
+    uploading: boolean;
+    uploadResult: any;
+    uploadError: any;
+    fileData: any;
+    uploadType: string | null;
+    uploadId: any;
+    totalChunks: number;
+    completedChunks: number;
+    chunkSize: any;
+    maxConcurrency: any;
+    uploadPromise: any;
+    get isStoredFile(): any;
+    get status(): "failed" | "uploading" | "uploaded" | "pending";
+    get filePath(): any;
+    get fileUrl(): any;
+    _initializeAndStartUpload(file: any, options: any): any;
+    /**
+     * Fast upload using S3 presigned URLs with multipart support
+     */
+    _fastUpload(file: any, options?: {}): any;
+    /**
+     * Handle single file upload
+     */
+    _singleUpload(file: any, uploadData: any, options: any): Promise<any>;
+    /**
+     * Handle multipart upload with concurrency using p-queue
+     */
+    _multipartUpload(file: any, uploadData: any, options: any): Promise<any>;
+    /**
+     * Create file chunks for multipart upload
+     */
+    _createFileChunks(file: any): any[];
+    /**
+     * Complete the upload (both single and multipart)
+     */
+    _completeUpload(filePath: any, originalName: any, uploadId?: null, parts?: null): Promise<any>;
+    /**
+     * Direct upload to Django backend (original method)
+     */
+    _directUpload(options?: {}): Promise<any>;
+    /**
+     * Reads the file content into an ArrayBuffer (for direct uploads only)
+     */
+    _readFileData(file: any): Promise<void>;
+    /**
+     * Gets the file data as a Blob (for direct uploads only)
+     */
+    getBlob(): Blob;
+    waitForUpload(): Promise<any>;
+}