@omniviewdev/runtime 0.24.0 → 0.26.0

package/dist/resource/v2/ancillary.d.ts

@@ -1,4 +1,4 @@
-import { AccessRoute, ResourceReference, SchemaBinding, ScopeEntry, Value } from './domain';
+import { AccessRoute, ResourceReference, ScopeEntry, Value } from './domain';
 import { Connection } from '../../bindings/github.com/omniviewdev/plugin-sdk/pkg/types/models';
 /** Ancillary transport traits; finite support comes only from the qualified catalog. */
 export type Feature = 'connections' | 'connectionBrowser' | 'connectionOverlay' | 'scopeValues' | 'presentation' | 'editorSchemas' | 'schemaDocuments' | 'relationships' | 'health' | 'actionCatalog' | 'streamingActions' | 'sourceSessions';
@@ -10,13 +10,6 @@ export interface ConnectionOverlay {
     upserts: readonly Connection[];
     disabledIDs: readonly string[];
 }
-export interface EditorSchema {
-    type: string;
-    fileMatch: string;
-    uri: string;
-    language: string;
-    binding: SchemaBinding;
-}
 export interface ResourceGroup {
     id: string;
     name: string;

package/dist/resource/v2/client.d.ts

@@ -1,6 +1,7 @@
 import { CancellablePromise } from '@wailsio/runtime';
 import { AccessRoute, ActionRequest, Catalog as CatalogResult, CatalogRequest, GetRequest, MutationRequest, Record, SchemaDocument, SchemaDocumentReference, Value } from './domain';
-import { ActionDescriptor, EditorSchema, FeatureSet, RelationshipDescriptor, ResolvedRelationship, ResourceDefinition, ResourceEvent, ResourceGroup, ResourceHealth } from './ancillary';
+import { ActionDescriptor, FeatureSet, RelationshipDescriptor, ResolvedRelationship, ResourceDefinition, ResourceEvent, ResourceGroup, ResourceHealth } from './ancillary';
+import { EditorSchemaAssociation, EditorSchemaDocument, SchemaFieldsRequest, SchemaFieldsResult } from './schema';
 import { AppError } from '../../errors/types';
 import { ConnectionProfile, ConnectionProfileCredentials, ConnectionProfileResult, HostConnectionState, HostEnumerateRequest, HostGetRequest, HostNativeQueryRequest, HostRecord, HostSourcePage, HostSourceStates, HostSourceViewOpened, HostSourceViewRequest, ResolvedResourceReference, ResolvedResourceTarget, ResolveReferenceRequest, ResolveTargetRequest } from './host';
 import { Connection } from '../../bindings/github.com/omniviewdev/plugin-sdk/pkg/types/models';
@@ -27,7 +28,9 @@ export declare const ResetConnectionProfile: (pluginID: string, id: string) => C
 export declare const RemoveConnection: (pluginID: string, id: string) => CancellablePromise<void>;
 export declare const GetResourceGroups: (pluginID: string, route: AccessRoute) => CancellablePromise<ResourceGroup[]>;
 export declare const GetResourceDefinition: (pluginID: string, route: AccessRoute, type: string) => CancellablePromise<ResourceDefinition>;
-export declare const GetEditorSchemas: (pluginID: string, route: AccessRoute) => CancellablePromise<EditorSchema[]>;
+export declare const GetSchemaFields: (pluginID: string, request: SchemaFieldsRequest) => CancellablePromise<SchemaFieldsResult>;
+export declare const GetEditorSchemas: (pluginID: string, route: AccessRoute) => CancellablePromise<EditorSchemaAssociation[]>;
+export declare const GetEditorSchemaDocument: (pluginID: string, route: AccessRoute, documentID: string) => CancellablePromise<EditorSchemaDocument>;
 export declare const GetRelationships: (pluginID: string, route: AccessRoute, type: string) => CancellablePromise<RelationshipDescriptor[]>;
 export declare const ResolveRelationships: (pluginID: string, request: GetRequest) => CancellablePromise<ResolvedRelationship[]>;
 export declare const GetHealth: (pluginID: string, request: GetRequest, body: Value) => CancellablePromise<ResourceHealth | null>;

package/dist/resource/v2/domain.d.ts

@@ -65,8 +65,6 @@ export interface SchemaBinding {
     root?: string;
     documentRef?: SchemaDocumentReference;
     document?: unknown;
-    validation: string;
-    unvalidated: readonly string[];
 }
 export interface SchemaDocumentReference {
     id: string;

package/dist/resource/v2/query-lease.d.ts

@@ -0,0 +1,145 @@
+import { ResourceReference, Value } from './domain';
+import { QuerySpec, RepresentationSelector } from './query';
+export type UInt64Text = string;
+export type Token = string;
+export type OpenQueryLeaseRequest = {
+    requestId: Token;
+    query: QuerySpec;
+    refresh?: true;
+};
+export type OpenQueryLeaseResponse = {
+    leaseId: Token;
+};
+export type ControlQueryLeaseRequest = {
+    leaseId: Token;
+    control: {
+        kind: 'attach';
+    } | {
+        kind: 'recover';
+        generation: Token;
+    } | {
+        kind: 'drain';
+    };
+};
+export type ControlQueryLeaseResponse = {
+    kind: 'attach';
+    generation: Token;
+} | {
+    kind: 'recover';
+    accepted: true;
+} | {
+    kind: 'drain';
+    event: QueryLeaseEvent | null;
+};
+export type CloseQueryLeaseRequest = {
+    leaseId: Token;
+};
+export type CloseQueryLeaseResponse = {
+    closed: true;
+};
+export type AppError = {
+    type: string;
+    title: string;
+    status: number;
+    detail: string;
+    instance?: string;
+    suggestions?: string[];
+    actions?: {
+        type: string;
+        label: string;
+        target?: string;
+    }[];
+    code?: string;
+    requestId?: string;
+    recovery?: string;
+    location?: {
+        start: number;
+        end: number;
+        unit: string;
+    };
+};
+export type ProjectedValue = {
+    state: 'absent';
+} | {
+    state: 'null';
+} | {
+    state: 'value';
+    value: Value;
+};
+export type ResultRow = {
+    key: Token;
+    targetId: string;
+    resource: ResourceReference;
+    representation: RepresentationSelector;
+    provenance: {
+        source: Token;
+        coverage: 'complete' | 'partial' | 'unknown';
+        stale: boolean;
+    };
+    values: Record<string, ProjectedValue>;
+};
+export type ResultMetadata = {
+    coverage: 'complete' | 'partial' | 'unknown';
+    limitations: string[];
+    freshness: 'current' | 'snapshot' | 'stale';
+    count: {
+        kind: 'unknown';
+    } | {
+        kind: 'exact' | 'estimate';
+        value: UInt64Text;
+    };
+    continuation?: Token;
+};
+export type ResultChange = {
+    kind: 'enter';
+    index: number;
+    row: ResultRow;
+} | {
+    kind: 'update';
+    key: Token;
+    row: ResultRow;
+} | {
+    kind: 'leave' | 'delete';
+    key: Token;
+} | {
+    kind: 'move';
+    key: Token;
+    index: number;
+};
+export type ResultDataFrame = {
+    lane: 'data';
+    leaseId: Token;
+    generation: Token;
+    sequence: UInt64Text;
+    payload: {
+        kind: 'open';
+        rows: ResultRow[];
+        metadata: ResultMetadata;
+    } | {
+        kind: 'changes';
+        changes: ResultChange[];
+        metadata: ResultMetadata;
+    };
+};
+export type ResultControlFrame = {
+    lane: 'control';
+    leaseId: Token;
+    payload: {
+        kind: 'reset';
+        generation: Token;
+        nextGeneration: Token;
+        reason: 'gap' | 'overflow' | 'sourceInvalidated' | 'bindingChanged';
+    } | {
+        kind: 'control';
+        state: 'complete';
+        generation: Token;
+    } | {
+        kind: 'close';
+        reason: 'closed' | 'cancelled' | 'failed' | 'accessInvalidated';
+        error?: AppError;
+    };
+};
+export type QueryLeaseEvent = ResultDataFrame | ResultControlFrame;
+export type QueryLeaseDoorbell = {
+    leaseId: Token;
+};

package/dist/resource/v2/query-observer.d.ts

@@ -0,0 +1,37 @@
+import { AppError, QueryLeaseEvent, ResultMetadata, ResultRow } from './query-lease';
+export type ObserverSnapshot = Readonly<{
+    status: 'attaching' | 'pending' | 'ready' | 'recovering' | 'complete' | 'closed';
+    generation?: string;
+    rows: readonly ResultRow[];
+    metadata?: ResultMetadata;
+    stale: boolean;
+    error?: AppError;
+}>;
+export type ObserverAction = {
+    kind: 'none';
+} | {
+    kind: 'recover';
+    generation: string;
+} | {
+    kind: 'reopen';
+};
+/** One instance per lease. Register the doorbell before calling attach(). */
+export declare class QueryLeaseObserver {
+    readonly leaseId: string;
+    readonly maxRows: number;
+    private snapshot;
+    private generation?;
+    private sequence;
+    private opened;
+    private recovering;
+    private previousReset?;
+    constructor(leaseId: string, maxRows: number);
+    getSnapshot(): ObserverSnapshot;
+    attach(generation: string): void;
+    /** A lost drain response cannot be retried: discard the lease and reopen. */
+    disconnected(): ObserverAction;
+    close(): void;
+    apply(event: QueryLeaseEvent): ObserverAction;
+    private fail;
+    private publish;
+}

package/dist/resource/v2/query.d.ts

@@ -0,0 +1,120 @@
+import { AccessRoute, QueryScope, Value } from './domain';
+export type QuerySpec = {
+    version: string;
+    targets: Target[];
+    predicate: Predicate;
+    declarations: Record<string, BindingType>;
+    bindings: Record<string, Value>;
+    text?: TextConstraint;
+    projection: Projection[];
+    order: OrderTerm[];
+    delivery: Delivery;
+};
+export type Target = {
+    targetId: string;
+    provider: string;
+    authority: string;
+    type: string;
+    accessRoute: AccessRoute;
+    representation: RepresentationSelector;
+    scope: QueryScope;
+};
+export type RepresentationSelector = {
+    id: string;
+    revision: string;
+};
+export type Predicate = {
+    language: 'cel';
+    profile: 'omniview.resource-predicate.v1';
+    source: string;
+} | {
+    language: 'builder';
+    version: 'omniview.builder.v1';
+    document: Builder;
+};
+export type BindingType = {
+    kind: 'bool' | 'string' | 'int64' | 'uint64' | 'double' | 'timestamp';
+} | {
+    kind: 'list';
+    element: BindingType;
+} | {
+    kind: 'map' | 'nullable';
+    value: BindingType;
+};
+export type PathSegment = {
+    kind: 'member';
+    name: string;
+} | {
+    kind: 'index';
+    index: number;
+};
+export type DocumentFieldPath = PathSegment[];
+export type TextConstraint = {
+    term: string;
+    fields: DocumentFieldPath[];
+    match: 'substring';
+    case: 'sensitive';
+    combine: 'any';
+};
+export type Projection = {
+    id: string;
+    path: DocumentFieldPath;
+};
+export type OrderTerm = {
+    path: DocumentFieldPath;
+    direction: 'asc' | 'desc';
+    missing: 'first' | 'last';
+    null: 'first' | 'last';
+};
+export type Delivery = {
+    mode: 'once' | 'follow';
+    pageSize: number;
+    after?: string;
+    allowPartial?: boolean;
+};
+export type Builder = {
+    version: 'omniview.builder.v1';
+    root: Node;
+};
+export type BuilderPath = {
+    root: 'resource' | {
+        element: string;
+    };
+    segments: DocumentFieldPath;
+};
+export type Operand = {
+    kind: 'parameter';
+    name: string;
+} | {
+    kind: 'literal';
+    type: BindingType;
+    value: Value;
+};
+export type Condition = {
+    kind: 'discriminatorEquals';
+    path: BuilderPath;
+    value: string | boolean;
+};
+export type Node = {
+    kind: 'state';
+    path: BuilderPath;
+    state: 'absent' | 'present' | 'null' | 'nonNull';
+} | {
+    kind: 'value';
+    path: BuilderPath;
+    op: 'equal' | 'notEqualPresent';
+    operand: Operand;
+    when?: Condition[];
+} | {
+    kind: 'all' | 'any';
+    children: Node[];
+} | {
+    kind: 'not';
+    child: Node;
+} | {
+    kind: 'exists';
+    path: BuilderPath;
+    element: string;
+    child: Node;
+    when?: Condition[];
+};

package/dist/resource/v2/schema.d.ts

@@ -0,0 +1,86 @@
+import { AccessRoute, Operation, Value } from './domain';
+export type PathSegmentKind = 'field' | 'mapValue' | 'item';
+export interface PathSegment {
+    Kind: PathSegmentKind;
+    Name?: string;
+}
+export interface BranchCondition {
+    Pointer: string;
+    Branch: number;
+    Combinator: 'anyOf' | 'oneOf';
+}
+export type SchemaFieldType = 'null' | 'boolean' | 'string' | 'integer' | 'number' | 'object' | 'array';
+export interface FieldInfo {
+    Segment: PathSegment;
+    /** Empty means any. */
+    Types: readonly SchemaFieldType[] | null;
+    Format: string;
+    Title: string;
+    Description: string;
+    Enum: readonly Value[] | null;
+    Presence: 'required' | 'optional' | 'unknown';
+    Nullable: 'yes' | 'no' | 'unknown';
+    Applicability: 'unconditional' | 'conditional';
+    Conditions: readonly BranchCondition[] | null;
+    CELChecking: 'static' | 'partial' | 'dynamic';
+    HasChildren: boolean;
+    /** Always "unsupported": a schema never grants native filtering. */
+    NativeFilter: 'unsupported';
+}
+export interface SchemaConstraint {
+    Pointer: string;
+    Keyword: string;
+}
+export type HostEvaluation = 'schemaChecked' | 'dynamic' | 'unavailable' | 'unsupported';
+export interface TypeOverlay {
+    Operations: readonly Operation[];
+    NativeQueryLanguages: readonly string[];
+    HostEvaluation: HostEvaluation;
+    /** Error code when HostEvaluation is unavailable or unsupported. */
+    HostEvaluationCode: string;
+    Validation: 'full' | 'reduced' | 'none';
+    Unvalidated: readonly SchemaConstraint[] | null;
+}
+export interface SchemaFieldsRequest {
+    route: AccessRoute;
+    type: string;
+    /** Empty selects the type's default representation. */
+    representation?: string;
+    path: readonly PathSegment[];
+}
+export interface SchemaFieldsResult {
+    catalogRevision: string;
+    type: string;
+    representation: string;
+    /** Provider binding state: absent | available | unavailable. */
+    schemaState: string;
+    schemaRevision?: string;
+    dialect?: string;
+    overlay: TypeOverlay;
+    fields: readonly FieldInfo[];
+    truncated: boolean;
+    truncationReason?: 'fields' | 'visits';
+}
+export type EditorSchemaStatus = 'available' | 'absent' | 'unavailable' | 'unsupported' | 'invalid' | 'limit';
+export interface EditorSchemaAssociation {
+    type: string;
+    representation?: string;
+    /** Auxiliary schema key; empty for catalog representations. */
+    key?: string;
+    language: string;
+    /** "file:///omniview-schema/<hex16>" */
+    modelDirectory: string;
+    /** "**\/omniview-schema/<hex16>/*" */
+    fileMatch: string;
+    /** Full hex document digest; set only when status is available. */
+    documentId?: string;
+    /** "#/definitions/n<id>"; set only when status is available. */
+    root?: string;
+    status: EditorSchemaStatus;
+    code?: string;
+}
+/** Host-rendered draft-07 editor document. */
+export interface EditorSchemaDocument {
+    documentId: string;
+    schema: unknown;
+}