@oddington/sdk 0.1.2 → 0.1.4

package/dist/types/packages/sdk/src/public.d.ts

@@ -12,6 +12,52 @@ export { RoutineRecordWriteError } from '../../../shared/record-write.js';
 export { AirtableOperationError } from '../../../shared/airtable-contract.js';
 export type { AirtableField, AirtableTable, AirtableRecord, AirtableListInput, AirtableGetInput, AirtableCreateInput, AirtableUpdateInput, AirtableDeleteInput, AirtableReceipt, AirtableWriteResult, AirtableClient, Connections } from '../../../shared/airtable-contract.js';
 export declare const connections: import('../../../shared/airtable-contract.js').Connections;
+export { DataOperationError } from '../../../shared/data-contract.js';
+export type { DataRepository, DataErrorCode, PublicValueDefinition, PublicField, CollectionSummary, CollectionSchema, QueryScalar, SelectionOptions, RecordSelection, RecordsQuery, DataValue, SelectedRecord, SelectionMetadata, RecordsResult, RecordIdentity, RecordUpdateSet, DataPublication, DataChangeSet, DataEffect } from '../../../shared/data-contract.js';
+export declare const data: {
+    repository(name: string): import('../../../shared/data-contract.js').DataRepository;
+};
+export { FileOperationError } from '../../../shared/files-contract.js';
+export type { File, FileInput, FileStorage, FileCreateInput, FileCreateOptions, FileErrorCode } from '../../../shared/files-contract.js';
+export declare const files: {
+    create(input: import('../../../shared/files-contract.js').FileCreateInput, options?: import('../../../shared/files-contract.js').FileCreateOptions): Promise<import('../../../shared/files-contract.js').File>;
+    get(id: string): Promise<import('../../../shared/files-contract.js').File>;
+    read(id: string): Promise<Response>;
+};
+/** The host's existing refreshing session source; supplies identity, never membership. */
+export type HostedSessionSource = {
+    getSession(): Promise<{
+        data: {
+            session: {
+                access_token: string;
+                expires_at?: number;
+                user: {
+                    id: string;
+                };
+            } | null;
+        };
+        error: unknown;
+    }>;
+    onAuthStateChange(callback: (event: string, session: {
+        access_token: string;
+        expires_at?: number;
+        user: {
+            id: string;
+        };
+    } | null) => void): {
+        data: {
+            subscription: {
+                unsubscribe(): void;
+            };
+        };
+    };
+};
+/** OS-owned HTTPS browser bootstrap. Reinitialization replaces the previous context. */
+export declare const os: {
+    init(options: {
+        auth: HostedSessionSource;
+    }): void;
+};
 export type InboxRequester = (path: string, init?: RequestInit) => Promise<Response>;
 export type RoutinePublicationClientOptions = {
     workspace?: string;

package/dist/types/shared/data-contract.d.ts

@@ -0,0 +1,140 @@
+/** Canonical value vocabulary shared by schema normalization and public reads. */
+export type DataValueDefinition<Extra extends object = object> = {
+    nullable: boolean;
+    many: boolean;
+    description?: string;
+    term?: string;
+} & Extra & ({
+    kind: 'string' | 'integer' | 'boolean';
+} | {
+    kind: 'number';
+    precision?: number;
+} | {
+    kind: 'date';
+    format?: 'month';
+} | {
+    kind: 'const';
+    value: string | number | boolean;
+} | {
+    kind: 'enum';
+    values: string[];
+} | {
+    kind: 'link';
+    to: string[];
+} | {
+    kind: 'object';
+    fields: Array<DataValueDefinition<Extra> & {
+        name: string;
+    }>;
+} | {
+    kind: 'map';
+    key: DataValueDefinition<Extra>;
+    value: DataValueDefinition<Extra>;
+});
+export type PublicValueDefinition = DataValueDefinition;
+export type PublicField = PublicValueDefinition & {
+    name: string;
+};
+export type CollectionSummary = {
+    name: string;
+    type: string;
+    description?: string;
+};
+export type CollectionSchema = CollectionSummary & {
+    fields: PublicField[];
+};
+export type QueryScalar = string | number | boolean | null;
+type LowerBound = {
+    $gt: number | string;
+    $gte?: never;
+} | {
+    $gte: number | string;
+    $gt?: never;
+};
+type UpperBound = {
+    $lt: number | string;
+    $lte?: never;
+} | {
+    $lte: number | string;
+    $lt?: never;
+};
+export type RangeCondition = ((LowerBound & {
+    $lt?: never;
+    $lte?: never;
+}) | (UpperBound & {
+    $gt?: never;
+    $gte?: never;
+}) | (LowerBound & UpperBound)) & {
+    $in?: never;
+};
+export type QueryCondition = QueryScalar | RangeCondition | {
+    $in: QueryScalar[];
+    $gt?: never;
+    $gte?: never;
+    $lt?: never;
+    $lte?: never;
+};
+export type SelectionOptions = {
+    where?: Record<string, QueryCondition>;
+    fields?: string[];
+    order?: Record<string, 'asc' | 'desc'>;
+    limit?: number;
+    count?: boolean;
+    after?: string;
+};
+export type RecordSelection = {
+    $?: SelectionOptions;
+    [link: string]: RecordSelection | SelectionOptions | undefined;
+};
+export type RecordsQuery = Record<string, RecordSelection>;
+export type DataValue = QueryScalar | DataValue[] | {
+    [field: string]: DataValue;
+};
+export type SelectedRecord = {
+    $ref: string;
+    $version: string;
+    [field: string]: DataValue;
+};
+export type SelectionMetadata = {
+    version: string;
+    collections: Record<string, {
+        count?: number;
+        next?: string;
+    }>;
+};
+export type RecordsResult = {
+    $meta: SelectionMetadata;
+    [collection: string]: SelectedRecord[] | SelectionMetadata;
+};
+export type RecordIdentity = Pick<SelectedRecord, '$ref' | '$version'>;
+export type RecordUpdateSet = Record<string, DataValue>;
+export type DataPublication = {
+    version: string;
+    created: [];
+    updated: RecordIdentity[];
+    deleted: [];
+};
+export interface DataChangeSet {
+    update(record: RecordIdentity, set: RecordUpdateSet): void;
+    validate(): Promise<void>;
+    publish(): Promise<DataPublication>;
+}
+export interface DataRepository {
+    collections: {
+        list(): Promise<CollectionSummary[]>;
+        schema(name: string): Promise<CollectionSchema>;
+    };
+    records: {
+        select(query: RecordsQuery): Promise<RecordsResult>;
+    };
+    changes(): DataChangeSet;
+}
+export type DataErrorCode = 'context_unavailable' | 'unauthenticated' | 'access_denied' | 'invalid_query' | 'request_too_large' | 'capacity' | 'unavailable' | 'invalid_change' | 'conflict' | 'publication_pending';
+export type DataEffect = 'unapplied' | 'uncertain' | 'applied';
+export declare class DataOperationError extends Error {
+    readonly code: DataErrorCode;
+    readonly retryable: boolean;
+    readonly effect?: DataEffect | undefined;
+    constructor(code: DataErrorCode, retryable?: boolean, effect?: DataEffect | undefined);
+}
+export {};

package/dist/types/shared/files-contract.d.ts

@@ -0,0 +1,66 @@
+/** Provider-neutral authored contract. Registries and object locations stay server-side. */
+export type FileStorage = 'local' | 'remote' | 'both';
+export type FileInput = Blob | Uint8Array | ReadableStream<Uint8Array>;
+export type FileCsvHints = {
+    encoding?: 'utf-8' | 'windows-1252';
+    delimiter?: ',' | ';' | '\t';
+    headerRow?: number;
+};
+export type FileCreateInput = {
+    file: FileInput;
+    size?: number;
+    path?: string;
+    name?: string;
+    storage?: FileStorage;
+    csv?: FileCsvHints;
+};
+export type FileCreateOptions = {
+    requestKey?: string;
+};
+export type File = {
+    id: string;
+    name: string;
+    path: string;
+    mediaType: string;
+    size: number;
+    sha256: string;
+    enrichments: Record<string, {
+        mediaType: string;
+        size: number;
+        sha256: string;
+    }>;
+    details: {
+        kind: 'csv';
+        encoding: 'utf-8' | 'windows-1252';
+        delimiter: ',' | ';' | '\t';
+        headerRow: number;
+        dataRows: number;
+    } | {
+        kind: 'pdf';
+        pages?: number;
+    } | {
+        kind: 'other';
+    };
+};
+export type FileErrorCode = 'invalid_input' | 'unsupported_context' | 'unauthenticated' | 'access_denied' | 'request_too_large' | 'conflict' | 'integrity' | 'unavailable' | 'capacity' | 'method_not_allowed';
+export declare class FileOperationError extends Error {
+    readonly code: FileErrorCode;
+    readonly status: number;
+    readonly retryable: boolean;
+    constructor(code: FileErrorCode, status: number, retryable?: boolean);
+}
+export declare const FILE_ID_PATTERN: RegExp;
+/** Treat descriptor transport as untrusted; no provider fields escape the boundary. */
+export declare function parseFileDescriptor(value: unknown): File;
+export declare function safeFileName(value: unknown): value is string;
+export declare function safeFilePath(value: unknown): value is string;
+/** Private transport metadata: normalized material options exclude the request key and size declaration. */
+export type FileCreateMetadata = {
+    name: string;
+    path: string;
+    storage: 'remote';
+    csv?: Required<FileCsvHints>;
+    size: number;
+    requestKey: string;
+};
+export declare function parseFileCreateMetadata(value: unknown, maxBytes: number): FileCreateMetadata;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oddington/sdk",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Oddington routine and response-handler SDK",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",