@oddington/sdk 0.1.27 → 0.1.29

package/dist/types/packages/sdk/src/data-schema-types.d.ts

@@ -0,0 +1,186 @@
+import type { CollectionSchema, DataRepository, PublicValueDefinition, RecordsQuery, RecordsResult, SelectionMetadata } from '../../../shared/data-contract.js';
+import type { DataRepositorySchemas } from './public.js';
+type ReadonlySchema<Value> = Value extends object ? {
+    readonly [Key in keyof Value]: ReadonlySchema<Value[Key]>;
+} : Value;
+type Catalogue = {
+    collections: readonly ReadonlySchema<CollectionSchema>[];
+};
+type Collection = Catalogue['collections'][number];
+type Definition = ReadonlySchema<PublicValueDefinition>;
+type Field = Definition & {
+    readonly name: string;
+};
+type Fields<Schema extends Collection> = Schema['fields'][number];
+type Named<Schema extends Collection, Name> = Extract<Fields<Schema>, {
+    name: Name;
+}>;
+type Targets<Schemas extends Catalogue, Link> = Link extends {
+    to: readonly (infer Type)[];
+} ? Extract<Schemas['collections'][number], {
+    type: Type;
+}> : never;
+type Scalar<Value> = Value extends {
+    kind: 'string' | 'date' | 'link';
+} ? string : Value extends {
+    kind: 'integer' | 'number';
+} ? number : Value extends {
+    kind: 'boolean';
+} ? boolean : Value extends {
+    kind: 'enum';
+    values: readonly (infer Choice)[];
+} ? Choice : Value extends {
+    kind: 'const';
+    value: infer Constant;
+} ? Constant : never;
+type ObjectValue<Fields extends Field> = {
+    -readonly [F in Fields as F['nullable'] extends true ? never : F['name']]: Value<F>;
+} & {
+    -readonly [F in Fields as F['nullable'] extends true ? F['name'] : never]?: Value<F>;
+};
+type SingleValue<D> = D extends {
+    kind: 'object';
+    fields: readonly (infer F extends Field)[];
+} ? ObjectValue<F> : D extends {
+    kind: 'map';
+    key: infer Key;
+    value: infer Item;
+} ? Partial<Record<Extract<Scalar<Key>, string | number>, Value<Item>>> : Scalar<D>;
+type Cardinality<D, Item> = (D extends {
+    many: true;
+} ? Item[] : Item) | (D extends {
+    nullable: true;
+} ? null : never);
+type Value<D> = Cardinality<D, SingleValue<D>>;
+type FilterField<Schema extends Collection> = Extract<Fields<Schema>, {
+    many: false;
+    kind: 'string' | 'integer' | 'number' | 'boolean' | 'date' | 'enum' | 'const' | 'link';
+}>;
+type Lower<V> = {
+    $gt: V;
+    $gte?: never;
+} | {
+    $gte: V;
+    $gt?: never;
+};
+type Upper<V> = {
+    $lt: V;
+    $lte?: never;
+} | {
+    $lte: V;
+    $lt?: never;
+};
+type Range<V> = ((Lower<V> & {
+    $lt?: never;
+    $lte?: never;
+}) | (Upper<V> & {
+    $gt?: never;
+    $gte?: never;
+}) | (Lower<V> & Upper<V>)) & {
+    $in?: never;
+};
+type Condition<F> = Scalar<F> | (F extends {
+    nullable: true;
+} ? null : never) | {
+    $in: Array<Scalar<F> | (F extends {
+        nullable: true;
+    } ? null : never)>;
+    $gt?: never;
+    $gte?: never;
+    $lt?: never;
+    $lte?: never;
+} | (F extends {
+    kind: 'integer' | 'number' | 'date';
+} ? Range<Scalar<F>> : never);
+type RefField = {
+    name: '$ref';
+    kind: 'string';
+    many: false;
+    nullable: false;
+};
+type Options<Schema extends Collection, Mode> = {
+    fields?: Array<Fields<Schema>['name'] | '$ref' | '$version'>;
+    where?: {
+        [F in FilterField<Schema> | RefField as F['name']]?: Condition<F>;
+    };
+} & (Mode extends 'one' ? {} : {
+    order?: {
+        [F in FilterField<Schema> | RefField as F['name']]?: 'asc' | 'desc';
+    };
+    limit?: number;
+}) & (Mode extends 'top' ? {
+    count?: boolean;
+    after?: string;
+} : {});
+type Exact<Actual, Allowed> = Actual extends Allowed ? Record<Exclude<keyof Actual, keyof Allowed>, never> : never;
+type ExactUnion<Actual, Allowed> = Allowed extends unknown ? Exact<Actual, Allowed> : never;
+type CheckWhere<Schema extends Collection, Actual> = {
+    [Key in keyof Actual]: Key extends (FilterField<Schema> | RefField)['name'] ? Actual[Key] extends object ? ExactUnion<Actual[Key], Condition<Extract<FilterField<Schema> | RefField, {
+        name: Key;
+    }>>> : unknown : never;
+};
+type CheckOptions<Schema extends Collection, Actual, Mode> = Exact<Actual, Options<Schema, Mode>> & {
+    [Key in keyof Actual]: Key extends 'where' ? CheckWhere<Schema, Actual[Key]> : Key extends 'order' ? Exact<Actual[Key], NonNullable<Options<Schema, Mode>[Extract<Key, keyof Options<Schema, Mode>>]>> : unknown;
+};
+type CheckSelection<Schemas extends Catalogue, Schema extends Collection, Query, Mode, Depth extends unknown[]> = Schema extends Collection ? {
+    [Key in keyof Query]: Key extends '$' ? CheckOptions<Schema, Query[Key], Mode> : Key extends Fields<Schema>['name'] ? Named<Schema, Key> extends infer Link extends {
+        kind: 'link';
+        many: boolean;
+    } ? Depth['length'] extends 4 ? never : CheckTargets<Schemas, Targets<Schemas, Link>, Query[Key], Link['many'] extends true ? 'many' : 'one', [...Depth, unknown]> : never : never;
+} : never;
+type UnionToIntersection<U> = (U extends unknown ? (value: U) => void : never) extends (value: infer I) => void ? I : never;
+type CheckTargets<Schemas extends Catalogue, Schema extends Collection, Query, Mode, Depth extends unknown[]> = UnionToIntersection<CheckSelection<Schemas, Schema, Query, Mode, Depth>>;
+type CheckQuery<Schemas extends Catalogue, Query> = {
+    [Name in keyof Query]: Name extends Schemas['collections'][number]['name'] ? CheckSelection<Schemas, Extract<Schemas['collections'][number], {
+        name: Name;
+    }>, Query[Name], 'top', []> : never;
+};
+type SelectedNames<Schema extends Collection, Query> = Query extends {
+    $: {
+        fields: readonly (infer Name)[];
+    };
+} ? Extract<Name, Fields<Schema>['name']> : Fields<Schema>['name'];
+type Expanded<Schemas extends Catalogue, F, Query> = F extends {
+    kind: 'link';
+} ? Cardinality<F, Project<Schemas, Targets<Schemas, F>, Query>> | (F extends {
+    many: false;
+} ? '$' extends keyof Query ? 'where' extends keyof NonNullable<Query['$']> ? null : never : never : never) : never;
+type Project<Schemas extends Catalogue, Schema extends Collection, Query> = Schema extends Collection ? {
+    $ref: string;
+    $version: string;
+} & {
+    [F in Fields<Schema> as F['nullable'] extends true ? never : F['name'] extends SelectedNames<Schema, Query> | Exclude<keyof Query, '$'> ? F['name'] : never]: F['name'] extends keyof Query ? Expanded<Schemas, F, Query[F['name']]> : Value<F>;
+} & {
+    [F in Fields<Schema> as F['nullable'] extends true ? F['name'] extends SelectedNames<Schema, Query> | Exclude<keyof Query, '$'> ? F['name'] : never : never]?: F['name'] extends keyof Query ? Expanded<Schemas, F, Query[F['name']]> : Value<F>;
+} : never;
+type OptionalKeys<Value> = {
+    [Key in keyof Value]-?: {} extends Pick<Value, Key> ? Key : never;
+}[keyof Value];
+type WidenedOptions<Options> = 'fields' extends keyof Options ? 'fields' extends OptionalKeys<Options> ? true : Options['fields'] extends readonly unknown[] ? number extends Options['fields']['length'] ? true : false : false : false;
+type WidenedSelection<Query> = string extends keyof Query ? true : [OptionalKeys<Query>] extends [never] ? '$' extends keyof Query ? WidenedOptions<Query['$']> extends true ? true : WidenedLinks<Query> : WidenedLinks<Query> : true;
+type WidenedLinks<Query> = true extends {
+    [Key in Exclude<keyof Query, '$'>]: WidenedSelection<Query[Key]>;
+}[Exclude<keyof Query, '$'>] ? true : false;
+type Widened<Query> = string extends keyof Query ? true : true extends {
+    [Name in keyof Query]: WidenedSelection<Query[Name]>;
+}[keyof Query] ? true : false;
+type Result<Schemas extends Catalogue, Query extends RecordsQuery> = Widened<Query> extends true ? RecordsResult<Query> : {
+    $meta: SelectionMetadata;
+} & {
+    [Name in keyof Query]: Project<Schemas, Extract<Schemas['collections'][number], {
+        name: Name;
+    }>, Query[Name]>[];
+};
+type Checked<Schemas extends Catalogue, Query> = Widened<Query> extends true ? unknown : CheckQuery<Schemas, Query>;
+type SchemaRepository<Schemas extends Catalogue> = Omit<DataRepository, 'records'> & {
+    records: Omit<DataRepository['records'], 'select' | 'pages' | 'all'> & {
+        select<const Query extends RecordsQuery>(query: Query & Checked<Schemas, Query>): Promise<Result<Schemas, Query>>;
+        pages<const Query extends RecordsQuery>(query: Query & Checked<Schemas, Query>): AsyncIterable<Result<Schemas, Query>>;
+        all<const Query extends RecordsQuery>(query: Query & Checked<Schemas, Query>, options: {
+            maxRecords: number;
+        }): Promise<Result<Schemas, Query>>;
+    };
+};
+/** Generated metadata refines declarations only; unknown aliases stay generic. */
+export type RepositoryFor<Name extends string> = string extends Name ? DataRepository : Name extends keyof DataRepositorySchemas ? DataRepositorySchemas[Name] extends Catalogue ? SchemaRepository<DataRepositorySchemas[Name]> : DataRepository : DataRepository;
+export {};

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

@@ -20,8 +20,11 @@ export type { 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, RecordsReadInput, RecordsReadResult, RecordsSearchOptions, RecordsSearchResult, HistoryListOptions, HistoryEntry, HistoryChangesOptions, HistoryChange, HistoryChangesResult, RecordIdentity, RecordCreation, RecordUpdateSet, DataPublication, DataChangeSet, DataEffect } from '../../../shared/data-contract.js';
+/** Reserved for OS-generated normalized schema snapshots; grants no runtime authority. */
+export interface DataRepositorySchemas {
+}
 export declare const data: {
-    repository(name: string): import('../../../shared/data-contract.js').DataRepository;
+    repository<const Name extends string>(name: Name): import('./data-schema-types.js').RepositoryFor<Name>;
 };
 export { FileOperationError } from '../../../shared/files-contract.js';
 export { InboxOperationError } from '../../../shared/inbox-member-contract.js';

package/dist/types/packages/sdk/src/routine-definition-types.d.ts

@@ -56,9 +56,11 @@ export type RoutineArtifactInput = Readonly<{
     sha256: string;
     content: Uint8Array | Blob | ReadableStream<Uint8Array>;
 }>;
+/** Historical artifacts may retain their original Attempt link. New remote
+ * artifacts belong directly to the Run and do not fabricate that identity. */
 export type RoutineArtifact = Readonly<{
     id: string;
-    attempt: string;
+    attempt?: string;
     name: string;
     mediaType: string;
     size: number;

package/package.json

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