@arcote.tech/arc 0.1.8 → 0.1.9

package/dist/telemetry/context.d.ts

@@ -0,0 +1,65 @@
+import type { Span } from '@opentelemetry/api';
+import type { AuthContext } from '../context/element';
+import { ArcLogger } from './logger';
+/**
+ * Extended context that includes telemetry capabilities
+ */
+export interface ArcTelemetryContext {
+    /**
+     * Log a message with automatic trace context
+     */
+    log: ArcLogger;
+    /**
+     * Create a child span for a specific operation
+     */
+    startSpan(name: string, attributes?: Record<string, string | number | boolean>): Span;
+    /**
+     * Execute a function within a new span
+     */
+    withSpan<T>(name: string, fn: (span: Span) => Promise<T> | T, attributes?: Record<string, string | number | boolean>): Promise<T>;
+    /**
+     * Add attributes to the current span
+     */
+    addSpanAttributes(attributes: Record<string, string | number | boolean>): void;
+    /**
+     * Add an event to the current span
+     */
+    addSpanEvent(name: string, attributes?: Record<string, string | number | boolean>): void;
+    /**
+     * Record an exception in the current span
+     */
+    recordException(error: Error | string): void;
+    /**
+     * Get the current trace ID
+     */
+    getTraceId(): string | undefined;
+    /**
+     * Get the current span ID
+     */
+    getSpanId(): string | undefined;
+}
+/**
+ * Create telemetry context for command/event handlers
+ */
+export declare function createTelemetryContext(authContext: AuthContext, operationType: 'command' | 'event' | 'listener' | 'view', operationName: string): ArcTelemetryContext;
+/**
+ * Extract trace context from headers (for HTTP requests)
+ */
+export declare function extractTraceContext(headers: Record<string, string | string[] | undefined>): import("@opentelemetry/api").Context;
+/**
+ * Inject trace context into headers (for outgoing HTTP requests)
+ */
+export declare function injectTraceContext(headers?: Record<string, string>): Record<string, string>;
+/**
+ * Run a function with extracted trace context
+ */
+export declare function withExtractedContext<T>(headers: Record<string, string | string[] | undefined>, fn: () => T): T;
+/**
+ * Get telemetry information from current context
+ */
+export declare function getCurrentTelemetryInfo(): {
+    traceId: string | undefined;
+    spanId: string | undefined;
+    isRecording: boolean;
+};
+//# sourceMappingURL=context.d.ts.map

package/dist/telemetry/index.d.ts

@@ -0,0 +1,47 @@
+export type { TelemetryProvider, TelemetryContext, Logger, SpanOptions, DatabaseTelemetry } from './interfaces';
+export { NoOpLogger, NoOpTelemetryContext, NoOpTelemetryProvider, NoOpDatabaseTelemetry, noOpTelemetryProvider, noOpDatabaseTelemetry, } from './no-op';
+export declare const initializeTelemetry: (...args: any[]) => never;
+export declare const getTelemetry: () => null;
+export declare const startSpan: (...args: any[]) => never;
+export declare const withSpan: (...args: any[]) => never;
+export declare const ArcTelemetry: {
+    new (): {};
+};
+export declare const initializeLogger: (...args: any[]) => never;
+export declare const getLogger: () => never;
+export declare const ArcLogger: {
+    new (): {};
+};
+export declare const createTelemetryContext: (...args: any[]) => never;
+export declare const extractTraceContext: (...args: any[]) => never;
+export declare const injectTraceContext: (...args: any[]) => never;
+export declare const withExtractedContext: (...args: any[]) => never;
+export declare const getCurrentTelemetryInfo: () => {
+    traceId: undefined;
+    spanId: undefined;
+    isRecording: boolean;
+};
+export type TelemetryConfig = any;
+export type LogContext = Record<string, any>;
+export type LogEntry = any;
+export type ArcTelemetryContext = any;
+export declare const SpanKind: {
+    readonly INTERNAL: "internal";
+    readonly SERVER: "server";
+    readonly CLIENT: "client";
+    readonly PRODUCER: "producer";
+    readonly CONSUMER: "consumer";
+};
+export declare const SpanStatusCode: {
+    readonly UNSET: 0;
+    readonly OK: 1;
+    readonly ERROR: 2;
+};
+export declare const LogLevel: {
+    readonly ERROR: "error";
+    readonly WARN: "warn";
+    readonly INFO: "info";
+    readonly DEBUG: "debug";
+    readonly TRACE: "trace";
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/telemetry/interfaces.d.ts

@@ -0,0 +1,84 @@
+import type { AuthContext } from '../context/element';
+/**
+ * Environment-agnostic telemetry context that handlers receive
+ * Automatically correlates logs with trace IDs
+ */
+export interface TelemetryContext {
+    /**
+     * Logging methods that auto-correlate with trace ID
+     */
+    log: {
+        info(message: string, context?: Record<string, any>): void;
+        error(message: string, context?: Record<string, any>, error?: Error): void;
+        debug(message: string, context?: Record<string, any>): void;
+        warn(message: string, context?: Record<string, any>): void;
+        command(name: string, message: string, context?: Record<string, any>): void;
+        event(type: string, message: string, context?: Record<string, any>): void;
+        database(operation: string, message: string, context?: Record<string, any>): void;
+        http(method: string, path: string, statusCode: number, duration: number, context?: Record<string, any>): void;
+    };
+    /**
+     * Span management (automatically correlates logs with traces)
+     */
+    startSpan(name: string, attributes?: Record<string, string | number | boolean>): void;
+    addAttributes(attributes: Record<string, string | number | boolean>): void;
+    addEvent(name: string, attributes?: Record<string, string | number | boolean>): void;
+    recordException(error: Error | string): void;
+    /**
+     * Trace correlation info
+     */
+    getTraceId(): string | undefined;
+    getSpanId(): string | undefined;
+}
+/**
+ * Span options for creating new spans
+ */
+export interface SpanOptions {
+    kind?: 'client' | 'server' | 'internal' | 'producer' | 'consumer';
+    attributes?: Record<string, string | number | boolean>;
+}
+/**
+ * Main telemetry provider interface that environments must implement
+ */
+export interface TelemetryProvider {
+    /**
+     * Create a logger instance
+     */
+    createLogger(name: string): Logger;
+    /**
+     * Execute function within a span context
+     */
+    withSpan<T>(name: string, fn: (context: TelemetryContext) => Promise<T> | T, options?: SpanOptions): Promise<T>;
+    /**
+     * Create telemetry context for command/route handlers
+     */
+    createTelemetryContext(authContext: AuthContext, operationType: 'command' | 'event' | 'listener' | 'view' | 'route', operationName: string): TelemetryContext;
+    /**
+     * Check if telemetry is enabled
+     */
+    isEnabled(): boolean;
+}
+/**
+ * Basic logger interface
+ */
+export interface Logger {
+    info(message: string, context?: Record<string, any>): void;
+    error(message: string, context?: Record<string, any>, error?: Error): void;
+    debug(message: string, context?: Record<string, any>): void;
+    warn(message: string, context?: Record<string, any>): void;
+    command(name: string, message: string, context?: Record<string, any>): void;
+    event(type: string, message: string, context?: Record<string, any>): void;
+    database(operation: string, message: string, context?: Record<string, any>): void;
+    http(method: string, path: string, statusCode: number, duration: number, context?: Record<string, any>): void;
+    child(context: Record<string, any>): Logger;
+}
+/**
+ * Database telemetry interface for adapters
+ */
+export interface DatabaseTelemetry {
+    /**
+     * Execute a database operation with telemetry
+     */
+    withDatabaseOperation<T>(operation: string, sql: string, params: any[] | undefined, tableName: string | undefined, fn: () => Promise<T>): Promise<T>;
+}
+//# sourceMappingURL=interfaces.d.ts.map

package/dist/telemetry/logger.d.ts

@@ -0,0 +1,67 @@
+export declare enum LogLevel {
+    ERROR = "error",
+    WARN = "warn",
+    INFO = "info",
+    DEBUG = "debug",
+    TRACE = "trace"
+}
+interface LogContext {
+    [key: string]: any;
+}
+interface LogEntry {
+    level: LogLevel;
+    message: string;
+    context?: LogContext;
+    timestamp?: string;
+    traceId?: string;
+    spanId?: string;
+    userId?: string;
+    requestId?: string;
+    command?: string;
+    event?: string;
+    error?: Error;
+}
+declare class ArcLogger {
+    private serviceName;
+    constructor(serviceName?: string);
+    private createLogEntry;
+    private formatForConsole;
+    private output;
+    private getSeverityNumber;
+    error(message: string, context?: LogContext, error?: Error): void;
+    warn(message: string, context?: LogContext): void;
+    info(message: string, context?: LogContext): void;
+    debug(message: string, context?: LogContext): void;
+    trace(message: string, context?: LogContext): void;
+    /**
+     * Log command execution
+     */
+    command(commandName: string, message: string, context?: LogContext): void;
+    /**
+     * Log event processing
+     */
+    event(eventType: string, message: string, context?: LogContext): void;
+    /**
+     * Log database operations
+     */
+    database(operation: string, message: string, context?: LogContext): void;
+    /**
+     * Log HTTP requests
+     */
+    http(method: string, path: string, statusCode: number, duration: number, context?: LogContext): void;
+    /**
+     * Create a child logger with additional context
+     */
+    child(context: LogContext): ArcLogger;
+}
+/**
+ * Initialize global logger
+ */
+export declare function initializeLogger(serviceName?: string): ArcLogger;
+/**
+ * Get the global logger instance
+ */
+export declare function getLogger(): ArcLogger;
+export { ArcLogger };
+export type { LogContext, LogEntry };
+//# sourceMappingURL=logger.d.ts.map

package/dist/telemetry/no-op.d.ts

@@ -0,0 +1,54 @@
+import type { TelemetryProvider, TelemetryContext, Logger, DatabaseTelemetry } from './interfaces';
+/**
+ * No-op logger implementation for when telemetry is disabled
+ */
+export declare class NoOpLogger implements Logger {
+    info(): void;
+    error(): void;
+    debug(): void;
+    warn(): void;
+    command(): void;
+    event(): void;
+    database(): void;
+    http(): void;
+    child(): Logger;
+}
+/**
+ * No-op telemetry context for when telemetry is disabled
+ */
+export declare class NoOpTelemetryContext implements TelemetryContext {
+    private logger;
+    log: NoOpLogger;
+    startSpan(): void;
+    addAttributes(): void;
+    addEvent(): void;
+    recordException(): void;
+    getTraceId(): undefined;
+    getSpanId(): undefined;
+}
+/**
+ * No-op telemetry provider for when telemetry is disabled
+ */
+export declare class NoOpTelemetryProvider implements TelemetryProvider {
+    private logger;
+    private context;
+    createLogger(): Logger;
+    withSpan<T>(name: string, fn: (context: TelemetryContext) => Promise<T> | T): Promise<T>;
+    createTelemetryContext(): TelemetryContext;
+    isEnabled(): boolean;
+}
+/**
+ * No-op database telemetry for when telemetry is disabled
+ */
+export declare class NoOpDatabaseTelemetry implements DatabaseTelemetry {
+    withDatabaseOperation<T>(operation: string, sql: string, params: any[] | undefined, tableName: string | undefined, fn: () => Promise<T>): Promise<T>;
+}
+/**
+ * Default no-op telemetry provider instance
+ */
+export declare const noOpTelemetryProvider: NoOpTelemetryProvider;
+/**
+ * Default no-op database telemetry instance
+ */
+export declare const noOpDatabaseTelemetry: NoOpDatabaseTelemetry;
+//# sourceMappingURL=no-op.d.ts.map

package/dist/telemetry/tracer.d.ts

@@ -0,0 +1,85 @@
+import { SpanKind, SpanStatusCode } from "@opentelemetry/api";
+import type { Span } from "@opentelemetry/api";
+interface TelemetryConfig {
+    serviceName: string;
+    serviceVersion: string;
+    environment: string;
+    otlpEndpoint?: string;
+    enabled?: boolean;
+}
+declare class ArcTelemetry {
+    private sdk?;
+    private tracer;
+    private logger;
+    private config;
+    constructor(config: TelemetryConfig);
+    private initialize;
+    /**
+     * Create a new span for tracing operations
+     */
+    startSpan(name: string, options?: {
+        kind?: SpanKind;
+        attributes?: Record<string, string | number | boolean>;
+        parent?: Span;
+    }): Span;
+    /**
+     * Execute a function within a span context
+     */
+    withSpan<T>(name: string, fn: (span: Span) => Promise<T> | T, options?: {
+        kind?: SpanKind;
+        attributes?: Record<string, string | number | boolean>;
+    }): Promise<T>;
+    /**
+     * Add attributes to the current active span
+     */
+    addSpanAttributes(attributes: Record<string, string | number | boolean>): void;
+    /**
+     * Add an event to the current active span
+     */
+    addSpanEvent(name: string, attributes?: Record<string, string | number | boolean>): void;
+    /**
+     * Record an exception in the current span
+     */
+    recordException(error: Error | string): void;
+    /**
+     * Shutdown telemetry (call on app shutdown)
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Check if telemetry is enabled
+     */
+    get isEnabled(): boolean;
+    /**
+     * Get the current tracer instance
+     */
+    getTracer(): any;
+    /**
+     * Get the current logger instance
+     */
+    getLogger(): any;
+}
+/**
+ * Initialize global telemetry
+ */
+export declare function initializeTelemetry(config: TelemetryConfig): ArcTelemetry;
+/**
+ * Get the global telemetry instance
+ */
+export declare function getTelemetry(): ArcTelemetry | null;
+/**
+ * Helper function to create a span
+ */
+export declare function startSpan(name: string, options?: {
+    kind?: SpanKind;
+    attributes?: Record<string, string | number | boolean>;
+}): Span;
+/**
+ * Helper function to execute code within a span
+ */
+export declare function withSpan<T>(name: string, fn: (span: Span) => Promise<T> | T, options?: {
+    kind?: SpanKind;
+    attributes?: Record<string, string | number | boolean>;
+}): Promise<T>;
+export { ArcTelemetry, SpanKind, SpanStatusCode };
+export type { TelemetryConfig };
+//# sourceMappingURL=tracer.d.ts.map

package/dist/utils.d.ts

@@ -1,7 +1,4 @@
-import type { ArcCollectionAny, CollectionItem } from "./collection/collection";
-import type { QueryCollectionResult } from "./collection/queries/find";
 import type { ArcElement } from "./elements/element";
-export * from "./utils/index";
 export declare namespace objectUtil {
     export type MergeShapes<U, V> = {
         [k in Exclude<keyof U, keyof V>]: U[k];
@@ -43,23 +40,7 @@ export declare namespace objectUtil {
 export declare namespace util {
     type FirstArgument<T> = T extends (arg: infer U, ...args: any[]) => any ? U : never;
     type GetType<Element extends ArcElement> = ReturnType<Element["deserialize"]>;
-    type CollectionItemWithId<C extends ArcCollectionAny> = ReturnType<C["deserialize"]>;
 }
-export type ContextTypes<Ctx extends {
-    elements: any[];
-}> = {
-    [key in keyof Ctx["elements"]]: Ctx["elements"][key] extends ArcCollectionAny ? {
-        [Collection in Ctx["elements"][number] as `${Collection["name"]}.bodyWithoutId`]: util.GetType<Collection["schema"]>;
-    } & {
-        [Collection in Ctx["elements"][number] as `${Collection["name"]}.setBody`]: objectUtil.addQuestionMarks<util.FirstArgument<Collection["schema"]["parse"]>>;
-    } & {
-        [Collection in Ctx["elements"][number] as `${Collection["name"]}.id`]: util.GetType<Collection["id"]>;
-    } & {
-        [Collection in Ctx["elements"][number] as `${Collection["name"]}.body`]: CollectionItem<Collection>;
-    } & {
-        [Collection in Ctx["elements"][number] as `${Collection["name"]}.queryCollectionResult`]: Omit<QueryCollectionResult<Collection>, "result">;
-    } : never;
-}[keyof Ctx["elements"]];
 export type DeepPartial<T> = {
     [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
 };

package/dist/view/view.d.ts

@@ -1,5 +1,5 @@
-import type { ArcEventAny, ArcEventInstance } from "../context";
-import { ArcContextElementWithStore, type ArcContextElementAny, type AuthContext, type ListenerConfig, type PublishEventFunction, type StoreSchema } from "../context/element";
+import { type ArcEventAny, type ArcEventInstance } from "../context";
+import { ArcContextElementWithStore, type ArcContextElementAny, type AuthContext, type DatabaseStoreSchema, type ListenerConfig, type PublishEventFunction } from "../context/element";
 import type { QueryBuilderContext } from "../context/query-builder-context";
 import type { DataStorage } from "../data-storage";
 import type { FindOptions, WhereCondition } from "../data-storage/types";
@@ -31,9 +31,10 @@ export declare class ArcView<Name extends string, Id extends ArcIdAny, Schema ex
     private _elements?;
     private _handler?;
     private _isAsync;
+    private _version?;
     private restrictions?;
     constructor(name: Name, id: Id, schema: Schema);
-    storeSchema: () => StoreSchema;
+    databaseStoreSchema: () => DatabaseStoreSchema;
     /**
      * Define read access restrictions for this view
      * @param restrictionsFn - Function that takes auth context and returns where condition for read access
@@ -42,6 +43,7 @@ export declare class ArcView<Name extends string, Id extends ArcIdAny, Schema ex
     use<const E extends ArcContextElementAny[]>(elements: E): ArcView<Name, Id, Schema, E>;
     description(description: string): ArcView<Name, Id, Schema, Elements>;
     async(): ArcView<Name, Id, Schema, Elements>;
+    version(version: number): ArcView<Name, Id, Schema, Elements>;
     handle<Handler extends ArcViewHandler<Elements, Id, Schema>>(handler: Handler): ArcView<Name, Id, Schema, Elements>;
     handleEvent<Event extends ArcEventAny>(event: Event, handler: ArcViewEventHandler<Id, Schema, ArcEventInstance<Event>>): ArcView<Name, Id, Schema, [...Elements, Event]>;
     /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arcote.tech/arc",
   "type": "module",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "private": false,
   "author": "Przemysław Krasiński [arcote.tech]",
   "description": "Arc is a framework designed to align code closely with business logic, streamlining development and enhancing productivity.",

package/dist/collection/collection.d.ts

@@ -1,81 +0,0 @@
-import { ArcContextElementWithStore, type AuthContext, type AuthorizationRestrictions, type StoreSchema } from "../context/element";
-import { type ArcIdAny } from "../elements/id";
-import { type ArcObjectAny } from "../elements/object";
-import { type $type, type DeepPartial, type objectUtil, type util } from "../utils";
-import type { QueryBuilderContext } from "../context/query-builder-context";
-import type { DataStorage } from "../data-storage";
-import type { FindOptions } from "../data-storage/types";
-import { ArcFindQueryBuilder } from "./query-builders/find";
-export type CollectionItem<C extends ArcCollectionAny> = objectUtil.simplify<{
-    _id: string;
-} & $type<C>>;
-export type Deserialize<Id extends ArcIdAny, Schema extends ArcObjectAny> = objectUtil.simplify<{
-    _id: $type<Id>;
-} & $type<Schema>>;
-export declare class ArcCollection<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny> extends ArcContextElementWithStore<{
-    type: "delete";
-    from: CollectionItem<ArcCollection<Name, Id, Schema>>;
-} | {
-    type: "set";
-    to: CollectionItem<ArcCollection<Name, Id, Schema>>;
-} | {
-    type: "modify";
-    from: CollectionItem<ArcCollection<Name, Id, Schema>>;
-    to: CollectionItem<ArcCollection<Name, Id, Schema>>;
-    changes: objectUtil.simplify<DeepPartial<util.FirstArgument<Schema["serialize"]>>>;
-} | {
-    type: "mutate";
-    from: CollectionItem<ArcCollection<Name, Id, Schema>>;
-    to: CollectionItem<ArcCollection<Name, Id, Schema>>;
-}, Name> {
-    readonly name: Name;
-    readonly id: Id;
-    readonly schema: Schema;
-    readonly options: ArcCollectionOptions<Id, Schema>;
-    private _restrictions?;
-    constructor(name: Name, id: Id, schema: Schema, options: ArcCollectionOptions<Id, Schema>);
-    storeSchema(): StoreSchema;
-    /**
-     * Default restrictions for collections - deny all by default
-     * Use the auth() method to define custom authorization logic
-     */
-    restrictions(authContext: AuthContext): AuthorizationRestrictions;
-    /**
-     * Define custom authorization restrictions for this collection
-     * @param restrictionsFn - Function that takes auth context and returns restrictions
-     */
-    auth(restrictionsFn: (authContext: AuthContext) => AuthorizationRestrictions): ArcCollection<Name, Id, Schema>;
-    serialize(data: objectUtil.simplify<{
-        _id: util.FirstArgument<Id["serialize"]>;
-    } & objectUtil.addQuestionMarks<util.FirstArgument<Schema["serialize"]>>>): objectUtil.simplify<{
-        _id: ReturnType<Id["serialize"]>;
-    } & ReturnType<Schema["serialize"]>>;
-    deserialize(data: objectUtil.simplify<{
-        _id: util.FirstArgument<Id["deserialize"]>;
-    } & objectUtil.addQuestionMarks<util.FirstArgument<Schema["deserialize"]>>>): Deserialize<Id, Schema>;
-    queryBuilder: (context: QueryBuilderContext) => {
-        find: (options?: FindOptions<CollectionItem<ArcCollection<Name, Id, Schema>>>) => ArcFindQueryBuilder<ArcCollection<Name, Id, Schema>>;
-    };
-    commandContext: (dataStorage: DataStorage, publishEvent: (event: this["$event"]) => Promise<void>) => {
-        add: (data: $type<Schema>) => Promise<{
-            id: any;
-        }>;
-        remove: (id: $type<Id>) => Promise<{
-            success: boolean;
-        }>;
-        set: (id: $type<Id>, data: $type<Schema>) => Promise<{
-            success: boolean;
-        }>;
-        find: (options: FindOptions<Deserialize<Id, Schema>>) => Promise<Deserialize<Id, Schema>[]>;
-        findOne: (where: FindOptions<Deserialize<Id, Schema>>["where"]) => Promise<Deserialize<Id, Schema> | undefined>;
-        modify: (id: $type<Id>, data: DeepPartial<$type<Schema>>) => Promise<void>;
-        edit: (id: $type<Id>, editCallback: (item: Deserialize<Id, Schema>) => void) => Promise<void>;
-    };
-}
-export type ArcCollectionAny = ArcCollection<any, any, any>;
-type ArcCollectionOptions<Id extends ArcIdAny, Schema extends ArcObjectAny> = {
-    sort?: (a: Deserialize<Id, Schema>, b: Deserialize<Id, Schema>) => number;
-};
-export declare function collection<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny>(name: Name, id: Id, schema: Schema, options?: ArcCollectionOptions<Id, Schema>): ArcCollection<Name, Id, Schema>;
-export {};
-//# sourceMappingURL=collection.d.ts.map

package/dist/collection/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./collection";
-export * from "./queries/abstract-collection-query";
-export * from "./queries/util";
-//# sourceMappingURL=index.d.ts.map

package/dist/collection/queries/abstract-collection-query.d.ts

@@ -1,14 +0,0 @@
-import { ArcSerializableQuery } from "../../context/serializable-query";
-import type { DataStorage, ListenerEvent, StoreState } from "../../data-storage";
-import type { ArcCollectionAny, CollectionItem } from "../collection";
-export declare abstract class ArcCollectionQuery<Collection extends ArcCollectionAny, Result, Params> extends ArcSerializableQuery<Result, Params> {
-    protected collection: Collection;
-    protected bindedChangeHandler: (changes: ListenerEvent<CollectionItem<Collection>>[]) => void;
-    private store;
-    constructor(collection: Collection, params: Params);
-    run(dataStorage: DataStorage): Promise<Result>;
-    protected abstract onChange(change: ListenerEvent<CollectionItem<Collection>>): Result | false;
-    protected abstract fetch(store: StoreState<CollectionItem<Collection>>): Promise<Result>;
-    protected changeHandler(changes: ListenerEvent<CollectionItem<Collection>>[]): void;
-}
-//# sourceMappingURL=abstract-collection-query.d.ts.map

package/dist/collection/queries/find.d.ts

@@ -1,29 +0,0 @@
-import type { ListenerEvent, StoreState } from "../../data-storage";
-import type { FindOptions } from "../../data-storage/types";
-import type { util } from "../../utils";
-import type { ArcCollectionAny, CollectionItem } from "../collection";
-import { ArcCollectionQuery } from "./abstract-collection-query";
-export declare class QueryCollectionResult<C extends ArcCollectionAny> {
-    private result;
-    constructor(result: CollectionItem<C>[]);
-    get(id: util.GetType<C["id"]> | null): ({
-        _id: string;
-    } & ReturnType<C["deserialize"]> extends infer T ? { [KeyType in keyof T]: ({
-        _id: string;
-    } & ReturnType<C["deserialize"]>)[KeyType]; } : never) | undefined;
-    map<U>(callbackfn: (value: CollectionItem<C>, index: number, array: CollectionItem<C>[]) => U): U[];
-    toArray(): ({
-        _id: string;
-    } & ReturnType<C["deserialize"]> extends infer T ? { [KeyType in keyof T]: ({
-        _id: string;
-    } & ReturnType<C["deserialize"]>)[KeyType]; } : never)[];
-}
-export declare class ArcFindQuery<Collection extends ArcCollectionAny> extends ArcCollectionQuery<Collection, QueryCollectionResult<Collection>, FindOptions<CollectionItem<Collection>>> {
-    protected params: FindOptions<CollectionItem<Collection>>;
-    constructor(collection: Collection, params: FindOptions<CollectionItem<Collection>>);
-    protected fetch(store: StoreState<CollectionItem<Collection>>): Promise<QueryCollectionResult<Collection>>;
-    protected checkItem(item: CollectionItem<Collection>): boolean;
-    protected onChange(change: ListenerEvent<CollectionItem<Collection>>): false | QueryCollectionResult<Collection>;
-    protected createResult(result: CollectionItem<Collection>[]): QueryCollectionResult<Collection>;
-}
-//# sourceMappingURL=find.d.ts.map

package/dist/collection/queries/one-item.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=one-item.d.ts.map

package/dist/collection/queries/util.d.ts

@@ -1,3 +0,0 @@
-import type { ArcContextAny, QueryFactoryFunction } from "../../context";
-export type QueryBuilderFunctionResult<QB extends QueryFactoryFunction<ArcContextAny>> = ReturnType<ReturnType<QB>["toQuery"]>["lastResult"];
-//# sourceMappingURL=util.d.ts.map

package/dist/collection/query-builders/find-by-id.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=find-by-id.d.ts.map

package/dist/collection/query-builders/find-one.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=find-one.d.ts.map

package/dist/collection/query-builders/find.d.ts

@@ -1,13 +0,0 @@
-import { QueryBuilderContext } from "../../context/query-builder-context";
-import type { FindOptions } from "../../data-storage/types";
-import { type ArcCollectionAny, type CollectionItem } from "../collection";
-import { ArcFindQuery } from "../queries/find";
-export declare class ArcFindQueryBuilder<C extends ArcCollectionAny> {
-    private collection;
-    protected queryContext: QueryBuilderContext;
-    protected options: FindOptions<CollectionItem<C>>;
-    constructor(collection: C, queryContext: QueryBuilderContext, options: FindOptions<CollectionItem<C>>);
-    toQuery(): ArcFindQuery<ArcCollectionAny>;
-    run(): import("../queries/find").QueryCollectionResult<ArcCollectionAny>;
-}
-//# sourceMappingURL=find.d.ts.map