@aerostack/core 0.6.1

package/README.md

@@ -0,0 +1,13 @@
+# @aerostack/core
+
+Shared core types and utilities for Aerostack SDKs.
+
+## Installation
+
+```bash
+npm install @aerostack/core
+```
+
+## Usage
+
+This package is used internally by other Aerostack SDKs.

package/dist/client.d.ts

@@ -0,0 +1,163 @@
+import { Product, Cart, AerostackRPC, CollectionItem, StoreConfig, ProductVariant, Category } from './types';
+export interface AerocallConfig {
+    baseUrl?: string;
+    apiKey?: string;
+    jwt?: string;
+    projectId?: string;
+}
+export declare class AerocallClient implements AerostackRPC {
+    private baseUrl;
+    private apiKey?;
+    private jwt?;
+    private projectId?;
+    constructor(config: AerocallConfig);
+    private request;
+    get db(): {
+        query: <T = any>(sql: string, params?: any[]) => Promise<T[]>;
+    };
+    get cache(): {
+        get: <T = any>(key: string) => Promise<{
+            value: T | null;
+            exists: boolean;
+        }>;
+        set: (key: string, value: any, ttl?: number) => Promise<{
+            success: boolean;
+        }>;
+        delete: (key: string) => Promise<{
+            success: boolean;
+        }>;
+    };
+    get queue(): {
+        enqueue: (type: string, data: any) => Promise<{
+            success: boolean;
+            jobId: string;
+        }>;
+    };
+    get ai(): {
+        chat: (messages: {
+            role: "user" | "assistant" | "system";
+            content: string;
+        }[], model?: string) => Promise<{
+            response: string;
+        }>;
+        search: {
+            ingest: (content: string, metadata?: Record<string, any>, type?: string) => Promise<{
+                success: boolean;
+            }>;
+            query: (text: string, options?: {
+                limit?: number;
+                threshold?: number;
+                filter?: Record<string, any>;
+            }) => Promise<{
+                results: any[];
+            }>;
+            delete: (id: string) => Promise<{
+                success: boolean;
+            }>;
+            deleteByType: (type: string) => Promise<{
+                success: boolean;
+            }>;
+            listTypes: () => Promise<{
+                types: string[];
+            }>;
+            configure: (options: {
+                embeddingModel: string;
+            }) => Promise<{
+                success: boolean;
+            }>;
+        };
+    };
+    get storage(): {
+        upload: (key: string, file: File | Blob, contentType?: string) => Promise<{
+            url: string;
+        }>;
+    };
+    get services(): {
+        invoke: <T = any>(serviceName: string, data?: any) => Promise<{
+            success: true;
+            result: T;
+        }>;
+    };
+    get auth(): {
+        signup: (data: {
+            email: string;
+            password: string;
+            name?: string;
+            customFields?: Record<string, any>;
+        }) => Promise<{
+            token: string;
+            user: any;
+        }>;
+        signin: (data: {
+            email: string;
+            password: string;
+        }) => Promise<{
+            token: string;
+            user: any;
+        }>;
+    };
+    collections(slug: string): {
+        list: (options?: {
+            status?: "draft" | "published";
+            limit?: number;
+        }) => Promise<CollectionItem[]>;
+        get: (itemId: string) => Promise<CollectionItem>;
+        create: (item: {
+            slug: string;
+            data: Record<string, any>;
+            status?: "draft" | "published";
+            author_id?: string;
+        }) => Promise<CollectionItem>;
+        update: (itemId: string, item: Partial<{
+            slug: string;
+            data: Record<string, any>;
+            status: string;
+            author_id?: string;
+        }>) => Promise<{
+            success: boolean;
+        }>;
+        delete: (itemId: string) => Promise<{
+            success: boolean;
+        }>;
+    };
+    ecommerce(): {
+        config: () => Promise<StoreConfig>;
+        products: {
+            list: (options?: {
+                category?: string;
+                page?: number;
+                limit?: number;
+                search?: string;
+            }) => Promise<{
+                products: Product[];
+                total: number;
+                page: number;
+                limit: number;
+            }>;
+            get: (slugOrId: string) => Promise<{
+                product: Product & {
+                    variants: ProductVariant[];
+                };
+            }>;
+        };
+        categories: {
+            list: () => Promise<{
+                categories: Category[];
+                total: number;
+            }>;
+        };
+        cart: (cartId: string) => {
+            get: () => Promise<Cart>;
+            addItem: (item: {
+                productId: string;
+                variant_id?: string;
+                quantity?: number;
+            }) => Promise<Cart>;
+        };
+        applyCoupon: (code: string) => Promise<{
+            valid: boolean;
+            discount_amount: number;
+            message?: string;
+        }>;
+    };
+}

package/dist/client.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AerocallClient = void 0;
+class AerocallClient {
+    constructor(config) {
+        this.baseUrl = config.baseUrl || 'https://api.aerocall.ai/v1';
+        this.apiKey = config.apiKey;
+        this.jwt = config.jwt;
+        this.projectId = config.projectId;
+    }
+    async request(path, method, body, isMultipart = false) {
+        const headers = {
+            'X-SDK-Version': '0.4.0'
+        };
+        if (!isMultipart) {
+            headers['Content-Type'] = 'application/json';
+        }
+        if (this.apiKey)
+            headers['X-API-Key'] = this.apiKey;
+        if (this.jwt)
+            headers['Authorization'] = `Bearer ${this.jwt}`;
+        if (this.projectId)
+            headers['X-Project-Id'] = this.projectId;
+        headers['X-Request-ID'] = crypto.randomUUID();
+        const response = await fetch(`${this.baseUrl}${path}`, {
+            method,
+            headers,
+            body: isMultipart ? body : (body ? JSON.stringify(body) : undefined)
+        });
+        if (!response.ok) {
+            const err = await response.json().catch(() => ({ error: { message: response.statusText } }));
+            throw new Error(err.error?.message || 'Unknown error');
+        }
+        return response.json();
+    }
+    get db() {
+        return {
+            query: async (sql, params) => {
+                const res = await this.request('/db/query', 'POST', { sql, params });
+                return (res?.results ?? []);
+            }
+        };
+    }
+    get cache() {
+        return {
+            get: (key) => this.request('/cache/get', 'POST', { key }),
+            set: (key, value, ttl) => this.request('/cache/set', 'POST', { key, value, ttl }),
+            delete: (key) => this.request('/cache/delete', 'POST', { key })
+        };
+    }
+    get queue() {
+        return {
+            enqueue: (type, data) => this.request('/queue/enqueue', 'POST', { type, data })
+        };
+    }
+    get ai() {
+        return {
+            chat: (messages, model) => this.request('/ai/chat', 'POST', { messages, model }),
+            search: {
+                ingest: (content, metadata, type) => this.request('/ai/search/ingest', 'POST', { content, metadata, type }),
+                query: (text, options) => this.request('/ai/search/query', 'POST', { text, ...options }),
+                delete: (id) => this.request('/ai/search/delete', 'POST', { id }),
+                deleteByType: (type) => this.request('/ai/search/deleteByType', 'POST', { type }),
+                listTypes: () => this.request('/ai/search/listTypes', 'GET'),
+                configure: (options) => this.request('/ai/search/configure', 'POST', options)
+            }
+        };
+    }
+    get storage() {
+        return {
+            upload: (key, file, contentType) => {
+                const formData = new FormData();
+                formData.append('key', key);
+                formData.append('file', file);
+                if (contentType)
+                    formData.append('contentType', contentType);
+                return this.request('/storage/upload', 'POST', formData, true);
+            }
+        };
+    }
+    get services() {
+        return {
+            invoke: (serviceName, data) => this.request('/services/invoke', 'POST', { serviceName, data })
+        };
+    }
+    get auth() {
+        return {
+            signup: (data) => this.request('/auth/signup', 'POST', data),
+            signin: (data) => this.request('/auth/signin', 'POST', data),
+        };
+    }
+    collections(slug) {
+        return {
+            list: (options) => this.request(`/collections/${slug}/items`, 'GET', options),
+            get: (itemId) => this.request(`/collections/${slug}/items/${itemId}`, 'GET'),
+            create: (item) => this.request(`/collections/${slug}/items`, 'POST', item),
+            update: (itemId, item) => this.request(`/collections/${slug}/items/${itemId}`, 'PUT', item),
+            delete: (itemId) => this.request(`/collections/${slug}/items/${itemId}`, 'DELETE'),
+        };
+    }
+    ecommerce() {
+        return {
+            config: () => this.request('/ecommerce/config', 'GET'),
+            products: {
+                list: (options) => this.request('/ecommerce/products', 'GET', options),
+                get: (slugOrId) => this.request(`/ecommerce/products/${slugOrId}`, 'GET'),
+            },
+            categories: {
+                list: () => this.request('/ecommerce/categories', 'GET'),
+            },
+            cart: (cartId) => ({
+                get: () => this.request(`/ecommerce/cart/${cartId}`, 'GET'),
+                addItem: (item) => this.request(`/ecommerce/cart/${cartId}/items`, 'POST', item),
+            }),
+            applyCoupon: (code) => this.request('/ecommerce/coupons/validate', 'POST', { code }),
+        };
+    }
+}
+exports.AerocallClient = AerocallClient;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { AerocallClient, AerocallConfig } from './client';
+export * from './types';
+export * from './types/gateway';
+export * from './schemas/registry';

package/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AerocallClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "AerocallClient", { enumerable: true, get: function () { return client_1.AerocallClient; } });
+__exportStar(require("./types"), exports);
+__exportStar(require("./types/gateway"), exports);
+__exportStar(require("./schemas/registry"), exports);

package/dist/schemas/registry.d.ts

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+export declare const RegistryConfigSchemaV1: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodString;
+    author: z.ZodOptional<z.ZodString>;
+    type: z.ZodEnum<{
+        feature: "feature";
+        utility: "utility";
+        hook: "hook";
+    }>;
+    dependencies: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    registryDependencies: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    files: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        target: z.ZodString;
+    }, z.core.$strip>>>>;
+    configuration: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        api_route: z.ZodOptional<z.ZodString>;
+        env: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type RegistryConfigV1 = z.infer<typeof RegistryConfigSchemaV1>;
+export declare const RegistryConfigSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodString;
+    author: z.ZodOptional<z.ZodString>;
+    type: z.ZodEnum<{
+        feature: "feature";
+        utility: "utility";
+        hook: "hook";
+    }>;
+    dependencies: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    registryDependencies: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    files: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        target: z.ZodString;
+    }, z.core.$strip>>>>;
+    configuration: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        api_route: z.ZodOptional<z.ZodString>;
+        env: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type RegistryConfig = z.infer<typeof RegistryConfigSchema>;
+/**
+ * Validates a configuration payload against the registry schema.
+ * @param config The raw configuration object
+ * @returns The successfully parsed and validated configuration, or throws a ZodError
+ */
+export declare function validateRegistryConfig(config: unknown): RegistryConfig;
+/**
+ * Safely validates a configuration payload against the registry schema.
+ * @param config The raw configuration object
+ * @returns An object conforming to SafeParseReturnType indicating whether validation was successful
+ */
+export declare function safeValidateRegistryConfig(config: unknown): z.ZodSafeParseResult<{
+    name: string;
+    version: string;
+    description: string;
+    type: "feature" | "utility" | "hook";
+    dependencies: string[];
+    registryDependencies: string[];
+    files: {
+        source: string;
+        target: string;
+    }[];
+    configuration: {
+        env: string[];
+        api_route?: string | undefined;
+    };
+    $schema?: string | undefined;
+    author?: string | undefined;
+}>;

package/dist/schemas/registry.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegistryConfigSchema = exports.RegistryConfigSchemaV1 = void 0;
+exports.validateRegistryConfig = validateRegistryConfig;
+exports.safeValidateRegistryConfig = safeValidateRegistryConfig;
+const zod_1 = require("zod");
+// The schema is versioned to allow backwards compatibility
+// Version 1 of the schema
+exports.RegistryConfigSchemaV1 = zod_1.z.object({
+    $schema: zod_1.z.string().url().optional(),
+    name: zod_1.z.string()
+        .min(2, "Name must be at least 2 characters")
+        .max(50, "Name must be less than 50 characters")
+        .regex(/^[a-z0-9-]+$/, "Name can only contain lowercase letters, numbers, and hyphens"),
+    version: zod_1.z.string()
+        .regex(/^\d+\.\d+\.\d+$/, "Version must follow semantic versioning (e.g., 1.0.0)"),
+    description: zod_1.z.string().min(10, "Description must be at least 10 characters"),
+    author: zod_1.z.string().optional(),
+    type: zod_1.z.enum(['feature', 'utility', 'hook']),
+    dependencies: zod_1.z.array(zod_1.z.string()).optional().default([]),
+    registryDependencies: zod_1.z.array(zod_1.z.string()).optional().default([]),
+    files: zod_1.z.array(zod_1.z.object({
+        source: zod_1.z.string(),
+        target: zod_1.z.string(),
+    })).min(1, "At least one file mapping is required").optional().default([]),
+    configuration: zod_1.z.object({
+        api_route: zod_1.z.string().optional(),
+        env: zod_1.z.array(zod_1.z.string()).optional().default([]),
+    }).optional().default({ env: [] }),
+});
+// Current registry schema version
+exports.RegistryConfigSchema = exports.RegistryConfigSchemaV1;
+/**
+ * Validates a configuration payload against the registry schema.
+ * @param config The raw configuration object
+ * @returns The successfully parsed and validated configuration, or throws a ZodError
+ */
+function validateRegistryConfig(config) {
+    return exports.RegistryConfigSchema.parse(config);
+}
+/**
+ * Safely validates a configuration payload against the registry schema.
+ * @param config The raw configuration object
+ * @returns An object conforming to SafeParseReturnType indicating whether validation was successful
+ */
+function safeValidateRegistryConfig(config) {
+    return exports.RegistryConfigSchema.safeParse(config);
+}

package/dist/types/gateway.d.ts

@@ -0,0 +1,42 @@
+export interface AerostackGatewayConfig {
+    models?: Array<{
+        id: string;
+        provider: string;
+        model: string;
+        role: string;
+        system_prompt?: string;
+        max_tokens?: number;
+        temperature?: number;
+        endpoint?: string;
+        format?: string;
+    }>;
+    routing?: string;
+}
+export interface GatewayMonetizationConfig {
+    managed_in_dashboard?: boolean;
+    billing_model: 'subscription' | 'pay_as_you_go' | 'freemium' | 'per_token' | 'per_minute';
+    credit_topup_enabled?: boolean;
+    per_model_cost_tracking?: boolean;
+    pricePer1kTokens?: number;
+    monthlyPrice?: number;
+    includedTokens?: number;
+}
+export interface GatewaySecurityConfig {
+    require_api_key?: boolean;
+    rate_limit?: {
+        strategy: string;
+        requests_per_minute: number;
+        burst: number;
+    };
+    allowed_origins?: string[];
+}
+export interface GatewayBillingPayload {
+    consumerId: string;
+    developerApiId: string;
+    metric?: string;
+    units: number;
+}
+export interface ConsumerKeyResponse {
+    key: string;
+    name?: string;
+}

package/dist/types/gateway.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types.d.ts

@@ -0,0 +1,288 @@
+export interface User {
+    id: string;
+    email: string;
+    name?: string;
+    avatar_url?: string;
+    created_at: number;
+    last_login_at?: number;
+    project_id?: string | null;
+    email_verified_at?: number;
+    phone?: string | null;
+    phone_verified_at?: number | null;
+}
+export interface Project {
+    id: string;
+    user_id: string;
+    name: string;
+    slug: string;
+    description?: string;
+    created_at: number;
+    updated_at: number;
+    is_public: number;
+    plan: 'free' | 'pro' | 'enterprise';
+    subdomain?: string;
+}
+export interface Component {
+    id: string;
+    project_id: string;
+    name: string;
+    schema: any;
+    status: 'processing' | 'completed' | 'failed';
+    created_at: number;
+    updated_at: number;
+}
+export interface Page {
+    id: string;
+    project_id: string;
+    name: string;
+    slug: string;
+    description?: string;
+    type: 'static' | 'collection' | 'dynamic';
+    status: 'draft' | 'published' | 'archived';
+    meta_title?: string;
+    meta_description?: string;
+    published_at?: number;
+    created_at: number;
+    updated_at: number;
+}
+export interface Product {
+    id: string;
+    project_id: string;
+    name: string;
+    slug: string;
+    description?: string;
+    thumbnail_url?: string;
+    base_price: number;
+    compare_at_price?: number;
+    status: 'draft' | 'published' | 'archived';
+    product_type: 'simple' | 'variable';
+    data: string;
+    created_at: number;
+    updated_at: number;
+}
+export interface ProductVariant {
+    id: string;
+    product_id: string;
+    name: string;
+    price?: number;
+    stock_quantity: number;
+    attributes: string;
+    created_at: number;
+}
+export interface Order {
+    id: string;
+    project_id: string;
+    order_number: string;
+    email: string;
+    status: 'pending' | 'processing' | 'shipped' | 'delivered' | 'cancelled' | 'refunded';
+    payment_status: 'unpaid' | 'paid' | 'partially_refunded' | 'refunded';
+    fulfillment_status: 'unfulfilled' | 'partially_fulfilled' | 'fulfilled' | 'cancelled';
+    currency: string;
+    subtotal: number;
+    grand_total: number;
+    created_at: number;
+}
+export interface Cart {
+    id: string;
+    project_id: string;
+    items: CartItem[];
+    created_at: number;
+    updated_at: number;
+    expires_at: number;
+    coupon_code?: string;
+}
+export interface CartItem {
+    id: string;
+    product_id: string;
+    variant_id?: string;
+    name: string;
+    price: number;
+    quantity: number;
+    thumbnail_url?: string;
+}
+export interface Customer {
+    id: string;
+    project_id: string;
+    email: string;
+    first_name?: string | null;
+    last_name?: string | null;
+    phone?: string | null;
+    created_at: number;
+}
+export interface AerostackRPC {
+    db: {
+        query<T = any>(sql: string, params?: any[]): Promise<T[]>;
+    };
+    cache: {
+        get<T = any>(key: string): Promise<{
+            value: T | null;
+            exists: boolean;
+        }>;
+        set(key: string, value: any, ttl?: number): Promise<{
+            success: boolean;
+        }>;
+        delete(key: string): Promise<{
+            success: boolean;
+        }>;
+    };
+    queue: {
+        enqueue(type: string, data: any): Promise<{
+            success: boolean;
+            jobId: string;
+        }>;
+    };
+    ai: {
+        chat(messages: Array<{
+            role: 'user' | 'assistant' | 'system';
+            content: string;
+        }>, model?: string): Promise<{
+            response: string;
+        }>;
+        search: {
+            ingest(content: string, metadata?: Record<string, any>, type?: string): Promise<{
+                success: boolean;
+            }>;
+            query(text: string, options?: {
+                limit?: number;
+                threshold?: number;
+                filter?: Record<string, any>;
+            }): Promise<{
+                results: any[];
+            }>;
+            delete(id: string): Promise<{
+                success: boolean;
+            }>;
+            deleteByType(type: string): Promise<{
+                success: boolean;
+            }>;
+            listTypes(): Promise<{
+                types: string[];
+            }>;
+            configure(options: {
+                embeddingModel: string;
+            }): Promise<{
+                success: boolean;
+            }>;
+        };
+    };
+    storage: {
+        upload(key: string, file: any, contentType?: string): Promise<{
+            url: string;
+        }>;
+    };
+    services: {
+        invoke<T = any>(serviceName: string, data?: any): Promise<{
+            success: true;
+            result: T;
+        }>;
+    };
+    auth: {
+        signup(data: {
+            email: string;
+            password: string;
+            name?: string;
+            customFields?: Record<string, any>;
+        }): Promise<{
+            token: string;
+            user: any;
+        }>;
+        signin(data: {
+            email: string;
+            password: string;
+        }): Promise<{
+            token: string;
+            user: any;
+        }>;
+    };
+    collections(slug: string): {
+        list(options?: {
+            status?: 'draft' | 'published';
+            limit?: number;
+        }): Promise<CollectionItem[]>;
+        get(itemId: string): Promise<CollectionItem>;
+        create(item: {
+            slug: string;
+            data: Record<string, any>;
+            status?: 'draft' | 'published';
+            author_id?: string;
+        }): Promise<CollectionItem>;
+        update(itemId: string, item: Partial<{
+            slug: string;
+            data: Record<string, any>;
+            status: string;
+            author_id?: string;
+        }>): Promise<{
+            success: boolean;
+        }>;
+        delete(itemId: string): Promise<{
+            success: boolean;
+        }>;
+    };
+    ecommerce(): {
+        config(): Promise<StoreConfig>;
+        products: {
+            list(options?: {
+                category?: string;
+                page?: number;
+                limit?: number;
+                search?: string;
+            }): Promise<{
+                products: Product[];
+                total: number;
+                page: number;
+                limit: number;
+            }>;
+            get(slugOrId: string): Promise<{
+                product: Product & {
+                    variants: ProductVariant[];
+                };
+            }>;
+        };
+        categories: {
+            list(): Promise<{
+                categories: Category[];
+                total: number;
+            }>;
+        };
+        cart(cartId: string): {
+            get(): Promise<Cart>;
+            addItem(item: {
+                productId: string;
+                variant_id?: string;
+                quantity?: number;
+            }): Promise<Cart>;
+        };
+        applyCoupon(code: string): Promise<{
+            valid: boolean;
+            discount_amount: number;
+            message?: string;
+        }>;
+    };
+}
+export interface CollectionItem {
+    id: string;
+    collection_id: string;
+    slug: string;
+    data: any;
+    status: 'draft' | 'published';
+    author_id?: string;
+    created_at: number;
+    updated_at: number;
+}
+export interface StoreConfig {
+    default_currency: string;
+    currency_symbol: string;
+    tax_percentage: number;
+    flat_shipping_rate: number;
+    free_shipping_threshold?: number;
+    shipping_enabled: boolean;
+    payment_provider?: string;
+}
+export interface Category {
+    id: string;
+    name: string;
+    slug: string;
+    description?: string;
+    image_url?: string;
+    sort_order: number;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@aerostack/core",
+  "version": "0.6.1",
+  "description": "Shared types and RPC client for Aerostack SDKs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "dependencies": {
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0"
+  }
+}

package/src/client.ts

@@ -0,0 +1,151 @@
+import { Product, Order, Cart, Customer, AerostackRPC, CollectionItem, StoreConfig, ProductVariant, Category } from './types';
+
+export interface AerocallConfig {
+    baseUrl?: string;
+    apiKey?: string;
+    jwt?: string;
+    projectId?: string;
+}
+
+export class AerocallClient implements AerostackRPC {
+    private baseUrl: string;
+    private apiKey?: string;
+    private jwt?: string;
+    private projectId?: string;
+
+    constructor(config: AerocallConfig) {
+        this.baseUrl = config.baseUrl || 'https://api.aerocall.ai/v1';
+        this.apiKey = config.apiKey;
+        this.jwt = config.jwt;
+        this.projectId = config.projectId;
+    }
+
+    private async request<T>(path: string, method: string, body?: any, isMultipart = false): Promise<T> {
+        const headers: Record<string, string> = {
+            'X-SDK-Version': '0.4.0'
+        };
+        if (!isMultipart) {
+            headers['Content-Type'] = 'application/json';
+        }
+        if (this.apiKey) headers['X-API-Key'] = this.apiKey;
+        if (this.jwt) headers['Authorization'] = `Bearer ${this.jwt}`;
+        if (this.projectId) headers['X-Project-Id'] = this.projectId;
+
+        headers['X-Request-ID'] = crypto.randomUUID();
+
+        const response = await fetch(`${this.baseUrl}${path}`, {
+            method,
+            headers,
+            body: isMultipart ? body : (body ? JSON.stringify(body) : undefined)
+        });
+
+        if (!response.ok) {
+            const err = await response.json().catch(() => ({ error: { message: response.statusText } }));
+            throw new Error((err as any).error?.message || 'Unknown error');
+        }
+        return response.json() as Promise<T>;
+    }
+
+    public get db() {
+        return {
+            query: async <T = any>(sql: string, params?: any[]) => {
+                const res = await this.request<{ results: T[]; meta?: any }>('/db/query', 'POST', { sql, params });
+                return (res?.results ?? []) as T[];
+            }
+        };
+    }
+
+    public get cache() {
+        return {
+            get: <T = any>(key: string) => this.request<{ value: T | null, exists: boolean }>('/cache/get', 'POST', { key }),
+            set: (key: string, value: any, ttl?: number) => this.request<{ success: boolean }>('/cache/set', 'POST', { key, value, ttl }),
+            delete: (key: string) => this.request<{ success: boolean }>('/cache/delete', 'POST', { key })
+        };
+    }
+
+    public get queue() {
+        return {
+            enqueue: (type: string, data: any) => this.request<{ success: boolean; jobId: string }>('/queue/enqueue', 'POST', { type, data })
+        };
+    }
+
+    public get ai() {
+        return {
+            chat: (messages: { role: 'user' | 'assistant' | 'system'; content: string }[], model?: string) =>
+                this.request<{ response: string }>('/ai/chat', 'POST', { messages, model }),
+            search: {
+                ingest: (content: string, metadata?: Record<string, any>, type?: string) =>
+                    this.request<{ success: boolean }>('/ai/search/ingest', 'POST', { content, metadata, type }),
+                query: (text: string, options?: { limit?: number; threshold?: number; filter?: Record<string, any> }) =>
+                    this.request<{ results: any[] }>('/ai/search/query', 'POST', { text, ...options }),
+                delete: (id: string) => this.request<{ success: boolean }>('/ai/search/delete', 'POST', { id }),
+                deleteByType: (type: string) => this.request<{ success: boolean }>('/ai/search/deleteByType', 'POST', { type }),
+                listTypes: () => this.request<{ types: string[] }>('/ai/search/listTypes', 'GET'),
+                configure: (options: { embeddingModel: string }) => this.request<{ success: boolean }>('/ai/search/configure', 'POST', options)
+            }
+        };
+    }
+
+    public get storage() {
+        return {
+            upload: (key: string, file: File | Blob, contentType?: string) => {
+                const formData = new FormData();
+                formData.append('key', key);
+                formData.append('file', file);
+                if (contentType) formData.append('contentType', contentType);
+                return this.request<{ url: string }>('/storage/upload', 'POST', formData, true);
+            }
+        };
+    }
+
+    public get services() {
+        return {
+            invoke: <T = any>(serviceName: string, data?: any) => this.request<{ success: true, result: T }>('/services/invoke', 'POST', { serviceName, data })
+        };
+    }
+
+    public get auth() {
+        return {
+            signup: (data: { email: string; password: string; name?: string; customFields?: Record<string, any> }) =>
+                this.request<{ token: string; user: any }>('/auth/signup', 'POST', data),
+            signin: (data: { email: string; password: string }) =>
+                this.request<{ token: string; user: any }>('/auth/signin', 'POST', data),
+        };
+    }
+
+    public collections(slug: string) {
+        return {
+            list: (options?: { status?: 'draft' | 'published'; limit?: number }) =>
+                this.request<CollectionItem[]>(`/collections/${slug}/items`, 'GET', options),
+            get: (itemId: string) =>
+                this.request<CollectionItem>(`/collections/${slug}/items/${itemId}`, 'GET'),
+            create: (item: { slug: string; data: Record<string, any>; status?: 'draft' | 'published'; author_id?: string }) =>
+                this.request<CollectionItem>(`/collections/${slug}/items`, 'POST', item),
+            update: (itemId: string, item: Partial<{ slug: string; data: Record<string, any>; status: string; author_id?: string }>) =>
+                this.request<{ success: boolean }>(`/collections/${slug}/items/${itemId}`, 'PUT', item),
+            delete: (itemId: string) =>
+                this.request<{ success: boolean }>(`/collections/${slug}/items/${itemId}`, 'DELETE'),
+        };
+    }
+
+    public ecommerce() {
+        return {
+            config: () => this.request<StoreConfig>('/ecommerce/config', 'GET'),
+            products: {
+                list: (options?: { category?: string; page?: number; limit?: number; search?: string }) =>
+                    this.request<{ products: Product[]; total: number; page: number; limit: number }>('/ecommerce/products', 'GET', options),
+                get: (slugOrId: string) =>
+                    this.request<{ product: Product & { variants: ProductVariant[] } }>(`/ecommerce/products/${slugOrId}`, 'GET'),
+            },
+            categories: {
+                list: () => this.request<{ categories: Category[]; total: number }>('/ecommerce/categories', 'GET'),
+            },
+            cart: (cartId: string) => ({
+                get: () => this.request<Cart>(`/ecommerce/cart/${cartId}`, 'GET'),
+                addItem: (item: { productId: string; variant_id?: string; quantity?: number }) =>
+                    this.request<Cart>(`/ecommerce/cart/${cartId}/items`, 'POST', item),
+            }),
+            applyCoupon: (code: string) => this.request<{ valid: boolean; discount_amount: number; message?: string }>('/ecommerce/coupons/validate', 'POST', { code }),
+        };
+    }
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export { AerocallClient, AerocallConfig } from './client';
+export * from './types';
+export * from './types/gateway';
+export * from './schemas/registry';

package/src/schemas/registry.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+
+// The schema is versioned to allow backwards compatibility
+// Version 1 of the schema
+export const RegistryConfigSchemaV1 = z.object({
+    $schema: z.string().url().optional(),
+    name: z.string()
+        .min(2, "Name must be at least 2 characters")
+        .max(50, "Name must be less than 50 characters")
+        .regex(/^[a-z0-9-]+$/, "Name can only contain lowercase letters, numbers, and hyphens"),
+    version: z.string()
+        .regex(/^\d+\.\d+\.\d+$/, "Version must follow semantic versioning (e.g., 1.0.0)"),
+    description: z.string().min(10, "Description must be at least 10 characters"),
+    author: z.string().optional(),
+    type: z.enum(['feature', 'utility', 'hook']),
+    dependencies: z.array(z.string()).optional().default([]),
+    registryDependencies: z.array(z.string()).optional().default([]),
+    files: z.array(z.object({
+        source: z.string(),
+        target: z.string(),
+    })).min(1, "At least one file mapping is required").optional().default([]),
+    configuration: z.object({
+        api_route: z.string().optional(),
+        env: z.array(z.string()).optional().default([]),
+    }).optional().default({ env: [] }),
+});
+
+export type RegistryConfigV1 = z.infer<typeof RegistryConfigSchemaV1>;
+
+// Current registry schema version
+export const RegistryConfigSchema = RegistryConfigSchemaV1;
+
+export type RegistryConfig = z.infer<typeof RegistryConfigSchema>;
+
+/**
+ * Validates a configuration payload against the registry schema.
+ * @param config The raw configuration object
+ * @returns The successfully parsed and validated configuration, or throws a ZodError
+ */
+export function validateRegistryConfig(config: unknown): RegistryConfig {
+    return RegistryConfigSchema.parse(config);
+}
+
+/**
+ * Safely validates a configuration payload against the registry schema.
+ * @param config The raw configuration object
+ * @returns An object conforming to SafeParseReturnType indicating whether validation was successful
+ */
+export function safeValidateRegistryConfig(config: unknown) {
+    return RegistryConfigSchema.safeParse(config);
+}

package/src/types/gateway.ts

@@ -0,0 +1,46 @@
+export interface AerostackGatewayConfig {
+    models?: Array<{
+        id: string;
+        provider: string;
+        model: string;
+        role: string;
+        system_prompt?: string;
+        max_tokens?: number;
+        temperature?: number;
+        endpoint?: string;
+        format?: string;
+    }>;
+    routing?: string;
+}
+
+export interface GatewayMonetizationConfig {
+    managed_in_dashboard?: boolean;
+    billing_model: 'subscription' | 'pay_as_you_go' | 'freemium' | 'per_token' | 'per_minute';
+    credit_topup_enabled?: boolean;
+    per_model_cost_tracking?: boolean;
+    pricePer1kTokens?: number;
+    monthlyPrice?: number;
+    includedTokens?: number;
+}
+
+export interface GatewaySecurityConfig {
+    require_api_key?: boolean;
+    rate_limit?: {
+        strategy: string;
+        requests_per_minute: number;
+        burst: number;
+    };
+    allowed_origins?: string[];
+}
+
+export interface GatewayBillingPayload {
+    consumerId: string;
+    developerApiId: string;
+    metric?: string;
+    units: number;
+}
+
+export interface ConsumerKeyResponse {
+    key: string;
+    name?: string;
+}

package/src/types.ts

@@ -0,0 +1,207 @@
+export interface User {
+    id: string;
+    email: string;
+    name?: string;
+    avatar_url?: string;
+    created_at: number;
+    last_login_at?: number;
+    project_id?: string | null;
+    email_verified_at?: number;
+    phone?: string | null;
+    phone_verified_at?: number | null;
+}
+
+export interface Project {
+    id: string;
+    user_id: string;
+    name: string;
+    slug: string;
+    description?: string;
+    created_at: number;
+    updated_at: number;
+    is_public: number;
+    plan: 'free' | 'pro' | 'enterprise';
+    subdomain?: string;
+}
+
+export interface Component {
+    id: string;
+    project_id: string;
+    name: string;
+    schema: any;
+    status: 'processing' | 'completed' | 'failed';
+    created_at: number;
+    updated_at: number;
+}
+
+export interface Page {
+    id: string;
+    project_id: string;
+    name: string;
+    slug: string;
+    description?: string;
+    type: 'static' | 'collection' | 'dynamic';
+    status: 'draft' | 'published' | 'archived';
+    meta_title?: string;
+    meta_description?: string;
+    published_at?: number;
+    created_at: number;
+    updated_at: number;
+}
+
+export interface Product {
+    id: string;
+    project_id: string;
+    name: string;
+    slug: string;
+    description?: string;
+    thumbnail_url?: string;
+    base_price: number;
+    compare_at_price?: number;
+    status: 'draft' | 'published' | 'archived';
+    product_type: 'simple' | 'variable';
+    data: string;
+    created_at: number;
+    updated_at: number;
+}
+
+export interface ProductVariant {
+    id: string;
+    product_id: string;
+    name: string;
+    price?: number;
+    stock_quantity: number;
+    attributes: string;
+    created_at: number;
+}
+
+export interface Order {
+    id: string;
+    project_id: string;
+    order_number: string;
+    email: string;
+    status: 'pending' | 'processing' | 'shipped' | 'delivered' | 'cancelled' | 'refunded';
+    payment_status: 'unpaid' | 'paid' | 'partially_refunded' | 'refunded';
+    fulfillment_status: 'unfulfilled' | 'partially_fulfilled' | 'fulfilled' | 'cancelled';
+    currency: string;
+    subtotal: number;
+    grand_total: number;
+    created_at: number;
+}
+
+export interface Cart {
+    id: string;
+    project_id: string;
+    items: CartItem[];
+    created_at: number;
+    updated_at: number;
+    expires_at: number;
+    coupon_code?: string;
+}
+
+export interface CartItem {
+    id: string;
+    product_id: string;
+    variant_id?: string;
+    name: string;
+    price: number;
+    quantity: number;
+    thumbnail_url?: string;
+}
+
+export interface Customer {
+    id: string;
+    project_id: string;
+    email: string;
+    first_name?: string | null;
+    last_name?: string | null;
+    phone?: string | null;
+    created_at: number;
+}
+
+export interface AerostackRPC {
+    db: {
+        query<T = any>(sql: string, params?: any[]): Promise<T[]>;
+    };
+    cache: {
+        get<T = any>(key: string): Promise<{ value: T | null; exists: boolean }>;
+        set(key: string, value: any, ttl?: number): Promise<{ success: boolean }>;
+        delete(key: string): Promise<{ success: boolean }>;
+    };
+    queue: {
+        enqueue(type: string, data: any): Promise<{ success: boolean; jobId: string }>;
+    };
+    ai: {
+        chat(messages: Array<{ role: 'user' | 'assistant' | 'system'; content: string }>, model?: string): Promise<{ response: string }>;
+        search: {
+            ingest(content: string, metadata?: Record<string, any>, type?: string): Promise<{ success: boolean }>;
+            query(text: string, options?: { limit?: number; threshold?: number; filter?: Record<string, any> }): Promise<{ results: any[] }>;
+            delete(id: string): Promise<{ success: boolean }>;
+            deleteByType(type: string): Promise<{ success: boolean }>;
+            listTypes(): Promise<{ types: string[] }>;
+            configure(options: { embeddingModel: string }): Promise<{ success: boolean }>;
+        };
+    };
+    storage: {
+        upload(key: string, file: any, contentType?: string): Promise<{ url: string }>;
+    };
+    services: {
+        invoke<T = any>(serviceName: string, data?: any): Promise<{ success: true; result: T }>;
+    };
+    auth: {
+        signup(data: { email: string; password: string; name?: string; customFields?: Record<string, any> }): Promise<{ token: string; user: any }>;
+        signin(data: { email: string; password: string }): Promise<{ token: string; user: any }>;
+    };
+    collections(slug: string): {
+        list(options?: { status?: 'draft' | 'published'; limit?: number }): Promise<CollectionItem[]>;
+        get(itemId: string): Promise<CollectionItem>;
+        create(item: { slug: string; data: Record<string, any>; status?: 'draft' | 'published'; author_id?: string }): Promise<CollectionItem>;
+        update(itemId: string, item: Partial<{ slug: string; data: Record<string, any>; status: string; author_id?: string }>): Promise<{ success: boolean }>;
+        delete(itemId: string): Promise<{ success: boolean }>;
+    };
+    ecommerce(): {
+        config(): Promise<StoreConfig>;
+        products: {
+            list(options?: { category?: string; page?: number; limit?: number; search?: string }): Promise<{ products: Product[]; total: number; page: number; limit: number }>;
+            get(slugOrId: string): Promise<{ product: Product & { variants: ProductVariant[] } }>;
+        };
+        categories: {
+            list(): Promise<{ categories: Category[]; total: number }>;
+        };
+        cart(cartId: string): {
+            get(): Promise<Cart>;
+            addItem(item: { productId: string; variant_id?: string; quantity?: number }): Promise<Cart>;
+        };
+        applyCoupon(code: string): Promise<{ valid: boolean; discount_amount: number; message?: string }>;
+    };
+}
+
+export interface CollectionItem {
+    id: string;
+    collection_id: string;
+    slug: string;
+    data: any;
+    status: 'draft' | 'published';
+    author_id?: string;
+    created_at: number;
+    updated_at: number;
+}
+
+export interface StoreConfig {
+    default_currency: string;
+    currency_symbol: string;
+    tax_percentage: number;
+    flat_shipping_rate: number;
+    free_shipping_threshold?: number;
+    shipping_enabled: boolean;
+    payment_provider?: string;
+}
+
+export interface Category {
+    id: string;
+    name: string;
+    slug: string;
+    description?: string;
+    image_url?: string;
+    sort_order: number;
+}