@objectstack/client 1.0.4 → 1.0.5

package/.turbo/turbo-build.log

@@ -0,0 +1,22 @@
+
+> @objectstack/client@1.0.5 build /home/runner/work/spec/spec/packages/client
+> tsup --config ../../tsup.config.ts
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Using tsup config: /home/runner/work/spec/spec/tsup.config.ts
+CLI Target: es2020
+CLI Cleaning output folder
+ESM Build start
+CJS Build start
+CJS dist/index.js     20.62 KB
+CJS dist/index.js.map 40.53 KB
+CJS ⚡️ Build success in 60ms
+ESM dist/index.mjs     19.46 KB
+ESM dist/index.mjs.map 40.47 KB
+ESM ⚡️ Build success in 61ms
+DTS Build start
+DTS ⚡️ Build success in 9730ms
+DTS dist/index.d.mts 10.28 KB
+DTS dist/index.d.ts  10.28 KB

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @objectstack/client
 
+## 1.0.5
+
+### Patch Changes
+
+- b1d24bd: refactor: migrate build system from tsc to tsup for faster builds
+  - Replaced `tsc` with `tsup` (using esbuild) across all packages
+  - Added shared `tsup.config.ts` in workspace root
+  - Added `tsup` as workspace dev dependency
+  - significantly improved build performance
+- Updated dependencies [b1d24bd]
+  - @objectstack/core@1.0.5
+  - @objectstack/spec@1.0.5
+
 ## 1.0.4
 
 ### Patch Changes

package/dist/index.d.mts

@@ -0,0 +1,333 @@
+import { FilterCondition, QueryAST, SortNode, AggregationNode } from '@objectstack/spec/data';
+import { GetDiscoveryResponse, StandardErrorCode, ErrorCategory, GetMetaTypesResponse, GetMetaItemsResponse, MetadataCacheRequest, MetadataCacheResponse, LoginRequest, SessionResponse, FileUploadResponse, BatchUpdateRequest, BatchUpdateResponse, BatchOptions } from '@objectstack/spec/api';
+export { BatchOperationResult, BatchOptions, BatchRecord, BatchUpdateRequest, BatchUpdateResponse, DeleteManyRequest, ErrorCategory, GetDiscoveryResponse, GetMetaItemsResponse, GetMetaTypesResponse, MetadataCacheRequest, MetadataCacheResponse, StandardErrorCode, UpdateManyRequest } from '@objectstack/spec/api';
+import { Logger } from '@objectstack/core';
+
+/**
+ * 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
+ */
+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
+ */
+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
+ */
+declare function createQuery<T = any>(object: string): QueryBuilder<T>;
+/**
+ * Create a type-safe filter builder
+ */
+declare function createFilter<T = any>(): FilterBuilder<T>;
+
+interface ClientConfig {
+    baseUrl: string;
+    token?: string;
+    /**
+     * Custom fetch implementation (e.g. node-fetch or for Next.js caching)
+     */
+    fetch?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+    /**
+     * Logger instance for debugging
+     */
+    logger?: Logger;
+    /**
+     * Enable debug logging
+     */
+    debug?: boolean;
+}
+/**
+ * Discovery Result
+ * Re-export from @objectstack/spec/api for convenience
+ */
+type DiscoveryResult = GetDiscoveryResponse;
+interface QueryOptions {
+    select?: string[];
+    filters?: Record<string, any>;
+    sort?: string | string[] | SortNode[];
+    top?: number;
+    skip?: number;
+    aggregations?: AggregationNode[];
+    groupBy?: string[];
+}
+interface PaginatedResult<T = any> {
+    value: T[];
+    count: number;
+}
+interface StandardError {
+    code: StandardErrorCode;
+    message: string;
+    category: ErrorCategory;
+    httpStatus: number;
+    retryable: boolean;
+    details?: Record<string, any>;
+}
+declare class ObjectStackClient {
+    private baseUrl;
+    private token?;
+    private fetchImpl;
+    private discoveryInfo?;
+    private logger;
+    constructor(config: ClientConfig);
+    /**
+     * Initialize the client by discovering server capabilities.
+     */
+    connect(): Promise<{
+        version: string;
+        apiName: string;
+        capabilities?: {
+            search: boolean;
+            files: boolean;
+            graphql: boolean;
+            analytics: boolean;
+            hub: boolean;
+            websockets: boolean;
+        } | undefined;
+        endpoints?: {
+            data: string;
+            metadata: string;
+            auth: string;
+            graphql?: string | undefined;
+            storage?: string | undefined;
+            automation?: string | undefined;
+            analytics?: string | undefined;
+            hub?: string | undefined;
+        } | undefined;
+    }>;
+    /**
+     * Metadata Operations
+     */
+    meta: {
+        /**
+         * Get all available metadata types
+         * Returns types like 'object', 'plugin', 'view', etc.
+         */
+        getTypes: () => Promise<GetMetaTypesResponse>;
+        /**
+         * Get all items of a specific metadata type
+         * @param type - Metadata type name (e.g., 'object', 'plugin')
+         */
+        getItems: (type: string) => Promise<GetMetaItemsResponse>;
+        /**
+         * Get a specific object definition by name
+         * @deprecated Use `getItem('object', name)` instead for consistency with spec protocol
+         * @param name - Object name (snake_case identifier)
+         */
+        getObject: (name: string) => Promise<any>;
+        /**
+         * Get a specific metadata item by type and name
+         * @param type - Metadata type (e.g., 'object', 'plugin')
+         * @param name - Item name (snake_case identifier)
+         */
+        getItem: (type: string, name: string) => Promise<any>;
+        /**
+         * Save a metadata item
+         * @param type - Metadata type (e.g., 'object', 'plugin')
+         * @param name - Item name
+         * @param item - The metadata content to save
+         */
+        saveItem: (type: string, name: string, item: any) => Promise<any>;
+        /**
+         * Get object metadata with cache support
+         * Supports ETag-based conditional requests for efficient caching
+         */
+        getCached: (name: string, cacheOptions?: MetadataCacheRequest) => Promise<MetadataCacheResponse>;
+        getView: (object: string, type?: "list" | "form") => Promise<any>;
+    };
+    /**
+     * Analytics Services
+     */
+    analytics: {
+        query: (payload: any) => Promise<any>;
+        meta: (cube: string) => Promise<any>;
+        explain: (payload: any) => Promise<any>;
+    };
+    /**
+     * Hub Management Services
+     */
+    hub: {
+        spaces: {
+            list: () => Promise<any>;
+            create: (payload: any) => Promise<any>;
+        };
+        plugins: {
+            install: (pkg: string, version?: string) => Promise<any>;
+        };
+    };
+    /**
+     * Authentication Services
+     */
+    auth: {
+        login: (request: LoginRequest) => Promise<SessionResponse>;
+        logout: () => Promise<void>;
+        me: () => Promise<SessionResponse>;
+    };
+    /**
+     * Storage Services
+     */
+    storage: {
+        upload: (file: any, scope?: string) => Promise<FileUploadResponse>;
+        getDownloadUrl: (fileId: string) => Promise<string>;
+    };
+    /**
+     * Automation Services
+     */
+    automation: {
+        trigger: (triggerName: string, payload: any) => Promise<any>;
+    };
+    /**
+     * Data Operations
+     */
+    data: {
+        /**
+         * Advanced Query using ObjectStack Query Protocol
+         * Supports both simplified options and full AST
+         */
+        query: <T = any>(object: string, query: Partial<QueryAST>) => Promise<PaginatedResult<T>>;
+        find: <T = any>(object: string, options?: QueryOptions) => Promise<PaginatedResult<T>>;
+        get: <T = any>(object: string, id: string) => Promise<T>;
+        create: <T = any>(object: string, data: Partial<T>) => Promise<T>;
+        createMany: <T = any>(object: string, data: Partial<T>[]) => Promise<T[]>;
+        update: <T = any>(object: string, id: string, data: Partial<T>) => Promise<T>;
+        /**
+         * Batch update multiple records
+         * Uses the new BatchUpdateRequest schema with full control over options
+         */
+        batch: (object: string, request: BatchUpdateRequest) => Promise<BatchUpdateResponse>;
+        /**
+         * Update multiple records (simplified batch update)
+         * Convenience method for batch updates without full BatchUpdateRequest
+         */
+        updateMany: <T = any>(object: string, records: Array<{
+            id: string;
+            data: Partial<T>;
+        }>, options?: BatchOptions) => Promise<BatchUpdateResponse>;
+        delete: (object: string, id: string) => Promise<{
+            success: boolean;
+        }>;
+        /**
+         * Delete multiple records by IDs
+         */
+        deleteMany: (object: string, ids: string[], options?: BatchOptions) => Promise<BatchUpdateResponse>;
+    };
+    /**
+     * Private Helpers
+     */
+    private isFilterAST;
+    private fetch;
+    /**
+     * Get the conventional route path for a given API endpoint type
+     * ObjectStack uses standard conventions: /api/v1/data, /api/v1/metadata, /api/v1/ui
+     */
+    private getRoute;
+}
+
+export { type ClientConfig, type DiscoveryResult, FilterBuilder, ObjectStackClient, type PaginatedResult, QueryBuilder, type QueryOptions, type StandardError, createFilter, createQuery };

package/dist/index.d.ts

@@ -1,7 +1,134 @@
-import { QueryAST, SortNode, AggregationNode } from '@objectstack/spec/data';
-import { BatchUpdateRequest, BatchUpdateResponse, BatchOptions, MetadataCacheRequest, MetadataCacheResponse, StandardErrorCode, ErrorCategory, GetDiscoveryResponse, GetMetaTypesResponse, GetMetaItemsResponse, LoginRequest, SessionResponse, FileUploadResponse } from '@objectstack/spec/api';
+import { FilterCondition, QueryAST, SortNode, AggregationNode } from '@objectstack/spec/data';
+import { GetDiscoveryResponse, StandardErrorCode, ErrorCategory, GetMetaTypesResponse, GetMetaItemsResponse, MetadataCacheRequest, MetadataCacheResponse, LoginRequest, SessionResponse, FileUploadResponse, BatchUpdateRequest, BatchUpdateResponse, BatchOptions } from '@objectstack/spec/api';
+export { BatchOperationResult, BatchOptions, BatchRecord, BatchUpdateRequest, BatchUpdateResponse, DeleteManyRequest, ErrorCategory, GetDiscoveryResponse, GetMetaItemsResponse, GetMetaTypesResponse, MetadataCacheRequest, MetadataCacheResponse, StandardErrorCode, UpdateManyRequest } from '@objectstack/spec/api';
 import { Logger } from '@objectstack/core';
-export interface ClientConfig {
+
+/**
+ * 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
+ */
+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
+ */
+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
+ */
+declare function createQuery<T = any>(object: string): QueryBuilder<T>;
+/**
+ * Create a type-safe filter builder
+ */
+declare function createFilter<T = any>(): FilterBuilder<T>;
+
+interface ClientConfig {
     baseUrl: string;
     token?: string;
     /**
@@ -21,8 +148,8 @@ export interface ClientConfig {
  * Discovery Result
  * Re-export from @objectstack/spec/api for convenience
  */
-export type DiscoveryResult = GetDiscoveryResponse;
-export interface QueryOptions {
+type DiscoveryResult = GetDiscoveryResponse;
+interface QueryOptions {
     select?: string[];
     filters?: Record<string, any>;
     sort?: string | string[] | SortNode[];
@@ -31,11 +158,11 @@ export interface QueryOptions {
     aggregations?: AggregationNode[];
     groupBy?: string[];
 }
-export interface PaginatedResult<T = any> {
+interface PaginatedResult<T = any> {
     value: T[];
     count: number;
 }
-export interface StandardError {
+interface StandardError {
     code: StandardErrorCode;
     message: string;
     category: ErrorCategory;
@@ -43,7 +170,7 @@ export interface StandardError {
     retryable: boolean;
     details?: Record<string, any>;
 }
-export declare class ObjectStackClient {
+declare class ObjectStackClient {
     private baseUrl;
     private token?;
     private fetchImpl;
@@ -202,5 +329,5 @@ export declare class ObjectStackClient {
      */
     private getRoute;
 }
-export { QueryBuilder, FilterBuilder, createQuery, createFilter } from './query-builder';
-export type { BatchUpdateRequest, BatchUpdateResponse, UpdateManyRequest, DeleteManyRequest, BatchOptions, BatchRecord, BatchOperationResult, MetadataCacheRequest, MetadataCacheResponse, StandardErrorCode, ErrorCategory, GetDiscoveryResponse, GetMetaTypesResponse, GetMetaItemsResponse } from '@objectstack/spec/api';
+
+export { type ClientConfig, type DiscoveryResult, FilterBuilder, ObjectStackClient, type PaginatedResult, QueryBuilder, type QueryOptions, type StandardError, createFilter, createQuery };