@objectstack/client 0.6.1 → 0.7.1

package/dist/query-builder.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Type-Safe Query Builder
+ *
+ * Provides a fluent API for building ObjectStack queries with:
+ * - Compile-time type checking
+ * - Intelligent code completion
+ * - Runtime validation
+ * - Type-safe filters and selections
+ */
+import { QueryAST, FilterCondition } from '@objectstack/spec/data';
+/**
+ * Type-safe filter builder
+ */
+export declare class FilterBuilder<T = any> {
+    private conditions;
+    /**
+     * Equality filter: field = value
+     */
+    equals<K extends keyof T>(field: K, value: T[K]): this;
+    /**
+     * Not equals filter: field != value
+     */
+    notEquals<K extends keyof T>(field: K, value: T[K]): this;
+    /**
+     * Greater than filter: field > value
+     */
+    greaterThan<K extends keyof T>(field: K, value: T[K]): this;
+    /**
+     * Greater than or equal filter: field >= value
+     */
+    greaterThanOrEqual<K extends keyof T>(field: K, value: T[K]): this;
+    /**
+     * Less than filter: field < value
+     */
+    lessThan<K extends keyof T>(field: K, value: T[K]): this;
+    /**
+     * Less than or equal filter: field <= value
+     */
+    lessThanOrEqual<K extends keyof T>(field: K, value: T[K]): this;
+    /**
+     * IN filter: field IN (value1, value2, ...)
+     */
+    in<K extends keyof T>(field: K, values: T[K][]): this;
+    /**
+     * NOT IN filter: field NOT IN (value1, value2, ...)
+     */
+    notIn<K extends keyof T>(field: K, values: T[K][]): this;
+    /**
+     * LIKE filter: field LIKE pattern
+     */
+    like<K extends keyof T>(field: K, pattern: string): this;
+    /**
+     * IS NULL filter: field IS NULL
+     */
+    isNull<K extends keyof T>(field: K): this;
+    /**
+     * IS NOT NULL filter: field IS NOT NULL
+     */
+    isNotNull<K extends keyof T>(field: K): this;
+    /**
+     * Build the filter condition
+     */
+    build(): FilterCondition;
+    /**
+     * Get raw conditions array
+     */
+    getConditions(): FilterCondition[];
+}
+/**
+ * Type-safe query builder
+ */
+export declare class QueryBuilder<T = any> {
+    private query;
+    private _object;
+    constructor(object: string);
+    /**
+     * Select specific fields
+     */
+    select<K extends keyof T>(...fields: K[]): this;
+    /**
+     * Add filters using a builder function
+     */
+    where(builderFn: (builder: FilterBuilder<T>) => void): this;
+    /**
+     * Add raw filter condition
+     */
+    filter(condition: FilterCondition): this;
+    /**
+     * Sort by fields
+     */
+    orderBy<K extends keyof T>(field: K, order?: 'asc' | 'desc'): this;
+    /**
+     * Limit the number of results
+     */
+    limit(count: number): this;
+    /**
+     * Skip records (for pagination)
+     */
+    skip(count: number): this;
+    /**
+     * Paginate results
+     */
+    paginate(page: number, pageSize: number): this;
+    /**
+     * Group by fields
+     */
+    groupBy<K extends keyof T>(...fields: K[]): this;
+    /**
+     * Build the final query AST
+     */
+    build(): QueryAST;
+    /**
+     * Get the current query state
+     */
+    getQuery(): Partial<QueryAST>;
+}
+/**
+ * Create a type-safe query builder for an object
+ */
+export declare function createQuery<T = any>(object: string): QueryBuilder<T>;
+/**
+ * Create a type-safe filter builder
+ */
+export declare function createFilter<T = any>(): FilterBuilder<T>;

package/dist/query-builder.js

@@ -0,0 +1,221 @@
+/**
+ * Type-Safe Query Builder
+ *
+ * Provides a fluent API for building ObjectStack queries with:
+ * - Compile-time type checking
+ * - Intelligent code completion
+ * - Runtime validation
+ * - Type-safe filters and selections
+ */
+/**
+ * Type-safe filter builder
+ */
+export class FilterBuilder {
+    constructor() {
+        this.conditions = [];
+    }
+    /**
+     * Equality filter: field = value
+     */
+    equals(field, value) {
+        this.conditions.push([field, '=', value]);
+        return this;
+    }
+    /**
+     * Not equals filter: field != value
+     */
+    notEquals(field, value) {
+        this.conditions.push([field, '!=', value]);
+        return this;
+    }
+    /**
+     * Greater than filter: field > value
+     */
+    greaterThan(field, value) {
+        this.conditions.push([field, '>', value]);
+        return this;
+    }
+    /**
+     * Greater than or equal filter: field >= value
+     */
+    greaterThanOrEqual(field, value) {
+        this.conditions.push([field, '>=', value]);
+        return this;
+    }
+    /**
+     * Less than filter: field < value
+     */
+    lessThan(field, value) {
+        this.conditions.push([field, '<', value]);
+        return this;
+    }
+    /**
+     * Less than or equal filter: field <= value
+     */
+    lessThanOrEqual(field, value) {
+        this.conditions.push([field, '<=', value]);
+        return this;
+    }
+    /**
+     * IN filter: field IN (value1, value2, ...)
+     */
+    in(field, values) {
+        this.conditions.push([field, 'in', values]);
+        return this;
+    }
+    /**
+     * NOT IN filter: field NOT IN (value1, value2, ...)
+     */
+    notIn(field, values) {
+        this.conditions.push([field, 'not_in', values]);
+        return this;
+    }
+    /**
+     * LIKE filter: field LIKE pattern
+     */
+    like(field, pattern) {
+        this.conditions.push([field, 'like', pattern]);
+        return this;
+    }
+    /**
+     * IS NULL filter: field IS NULL
+     */
+    isNull(field) {
+        this.conditions.push([field, 'is_null', null]);
+        return this;
+    }
+    /**
+     * IS NOT NULL filter: field IS NOT NULL
+     */
+    isNotNull(field) {
+        this.conditions.push([field, 'is_not_null', null]);
+        return this;
+    }
+    /**
+     * Build the filter condition
+     */
+    build() {
+        if (this.conditions.length === 0) {
+            throw new Error('Filter builder has no conditions');
+        }
+        if (this.conditions.length === 1) {
+            return this.conditions[0];
+        }
+        // Combine multiple conditions with AND
+        return ['and', ...this.conditions];
+    }
+    /**
+     * Get raw conditions array
+     */
+    getConditions() {
+        return this.conditions;
+    }
+}
+/**
+ * Type-safe query builder
+ */
+export class QueryBuilder {
+    constructor(object) {
+        this.query = {};
+        this._object = object;
+        this.query.object = object;
+    }
+    /**
+     * Select specific fields
+     */
+    select(...fields) {
+        this.query.fields = fields;
+        return this;
+    }
+    /**
+     * Add filters using a builder function
+     */
+    where(builderFn) {
+        const builder = new FilterBuilder();
+        builderFn(builder);
+        const conditions = builder.getConditions();
+        if (conditions.length === 1) {
+            this.query.where = conditions[0];
+        }
+        else if (conditions.length > 1) {
+            this.query.where = ['and', ...conditions];
+        }
+        return this;
+    }
+    /**
+     * Add raw filter condition
+     */
+    filter(condition) {
+        this.query.where = condition;
+        return this;
+    }
+    /**
+     * Sort by fields
+     */
+    orderBy(field, order = 'asc') {
+        if (!this.query.orderBy) {
+            this.query.orderBy = [];
+        }
+        this.query.orderBy.push({
+            field: field,
+            order
+        });
+        return this;
+    }
+    /**
+     * Limit the number of results
+     */
+    limit(count) {
+        this.query.limit = count;
+        return this;
+    }
+    /**
+     * Skip records (for pagination)
+     */
+    skip(count) {
+        this.query.offset = count;
+        return this;
+    }
+    /**
+     * Paginate results
+     */
+    paginate(page, pageSize) {
+        this.query.limit = pageSize;
+        this.query.offset = (page - 1) * pageSize;
+        return this;
+    }
+    /**
+     * Group by fields
+     */
+    groupBy(...fields) {
+        this.query.groupBy = fields;
+        return this;
+    }
+    /**
+     * Build the final query AST
+     */
+    build() {
+        return {
+            object: this._object,
+            ...this.query
+        };
+    }
+    /**
+     * Get the current query state
+     */
+    getQuery() {
+        return { ...this.query };
+    }
+}
+/**
+ * Create a type-safe query builder for an object
+ */
+export function createQuery(object) {
+    return new QueryBuilder(object);
+}
+/**
+ * Create a type-safe filter builder
+ */
+export function createFilter() {
+    return new FilterBuilder();
+}

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@objectstack/client",
-  "version": "0.6.1",
+  "version": "0.7.1",
   "description": "Official Client SDK for ObjectStack Protocol",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "dependencies": {
-    "@objectstack/spec": "0.6.1"
+    "@objectstack/spec": "0.7.1",
+    "@objectstack/core": "0.7.1"
   },
   "devDependencies": {
     "typescript": "^5.0.0"