@diagonal-hq/cli 0.0.0-stage → 0.2.0

package/dist/workflow/console.d.ts

@@ -0,0 +1,10 @@
+declare global {
+    interface Console {
+        log(...values: unknown[]): void;
+        info(...values: unknown[]): void;
+        warn(...values: unknown[]): void;
+        error(...values: unknown[]): void;
+    }
+    var console: Console;
+}
+export {};

package/dist/workflow/data.d.ts

@@ -0,0 +1,124 @@
+import { type DataCountInput, type DataCreateInput, type DataCreateManyInput, type DataDeleteInput, type DataDeleteManyInput, type DataDeleteManyOutput, type DataFindInput, type DataFindOrCreateInput, type DataRestoreInput, type DataSearchInput, type DataSearchOutput, type DataUpdateInput, type DataUpdateOrCreateInput } from './generated/capabilities';
+import type { WorkspaceResources } from './index';
+type Entry = WorkspaceResources[keyof WorkspaceResources];
+export type ResourceKey = [keyof WorkspaceResources] extends [never] ? string : Entry extends {
+    id: infer I;
+} ? I : never;
+/** The id of each entry of `E` that has every capability in `C`. */
+type IdWithCapabilities<E, C extends string> = E extends {
+    id: infer I;
+    capabilities: infer Declared;
+} ? [C] extends [Declared] ? I : never : never;
+/**
+ * The ids of the resources that have every capability in `C`. Any string while the workspace
+ * declares no resources.
+ */
+export type ResourceKeyWith<C extends string> = [keyof WorkspaceResources] extends [never] ? string : IdWithCapabilities<Entry, C>;
+type EntryFor<R> = Extract<Entry, {
+    id: R;
+}>;
+export type InputOf<R> = [EntryFor<R>] extends [never] ? Record<string, unknown> : EntryFor<R> extends {
+    input: infer I;
+} ? I : never;
+export type RecordOf<R> = [EntryFor<R>] extends [never] ? {
+    id: string;
+} & Record<string, unknown> : EntryFor<R> extends {
+    record: infer T;
+} ? T : never;
+/** The declared keys of `T`. `keyof` on a type with an index signature returns only `string | number`. */
+type DeclaredKey<T> = keyof {
+    [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K];
+};
+/**
+ * `DataSearchOutput` with `data` narrowed to the resource's record shape and `cursor` narrowed to
+ * the cursor text. `pagination` stays as generated.
+ */
+type SearchOutput<R> = Pick<DataSearchOutput, Exclude<DeclaredKey<DataSearchOutput>, 'data' | 'cursor'>> & {
+    data?: Array<RecordOf<R>>;
+    /** With `paging: 'cursor'`, the `after` value for the next page. Null when no records are left. */
+    cursor?: string | null;
+    [key: string]: unknown;
+};
+type EachInput<R> = Omit<DataSearchInput, 'resource' | 'page' | 'pageSize' | 'paging' | 'after'> & {
+    resource: R;
+    /** Stop after this many records. Leave it out to visit every match. */
+    maxRecords?: number;
+};
+/**
+ * Visit every record that the search matches, one record at a time, with cursor paging. The
+ * query is copied when `each` is called, so a change to the input object during the walk does
+ * not change the pages.
+ *
+ * Each page continues after the last record of the page before it. A record that the loop body
+ * updates so that it no longer matches, or deletes, does not move a later page. A body that
+ * changes the value of a `sort` field can move a visited record after the cursor, and the walk
+ * then visits it again. Sort on a field that the body does not change, or leave `sort` empty.
+ */
+declare function each<R extends ResourceKey>(input: EachInput<R>): AsyncGenerator<RecordOf<R>, void, undefined>;
+export declare const data: {
+    create: <R extends ResourceKey>(input: Omit<DataCreateInput, "resource" | "data"> & {
+        resource: R;
+        data: InputOf<R>;
+    }) => Promise<{
+        id: string;
+    } & Record<string, unknown>>;
+    find: <R extends ResourceKey>(input: Omit<DataFindInput, "resource"> & {
+        resource: R;
+    }) => Promise<{
+        id: string;
+    } & Record<string, unknown>>;
+    update: <R extends ResourceKey>(input: Omit<DataUpdateInput, "resource" | "data"> & {
+        resource: R;
+        data: InputOf<R>;
+    }) => Promise<{
+        id: string;
+    } & Record<string, unknown>>;
+    search: <R extends ResourceKey>(input: Omit<DataSearchInput, "resource"> & {
+        resource: R;
+    }) => Promise<SearchOutput<R>>;
+    each: typeof each;
+    delete: <R extends ResourceKey>(input: Omit<DataDeleteInput, "resource"> & {
+        resource: R;
+    }) => Promise<{
+        id: string;
+    } & Record<string, unknown>>;
+    restore: <R extends ResourceKey>(input: Omit<DataRestoreInput, "resource"> & {
+        resource: R;
+    }) => Promise<{
+        id: string;
+    } & Record<string, unknown>>;
+    count: <R extends ResourceKey>(input: Omit<DataCountInput, "resource"> & {
+        resource: R;
+    }) => Promise<number>;
+    findOrCreate: <R extends ResourceKey>(input: Omit<DataFindOrCreateInput, "resource"> & {
+        resource: R;
+    }) => Promise<{
+        id: string;
+    } & Record<string, unknown>>;
+    updateOrCreate: <R extends ResourceKey>(input: Omit<DataUpdateOrCreateInput, "resource"> & {
+        resource: R;
+    }) => Promise<{
+        id: string;
+    } & Record<string, unknown>>;
+    createMany: <R extends ResourceKey>(input: Omit<DataCreateManyInput, "resource" | "records"> & {
+        resource: R;
+        records: Array<InputOf<R>>;
+    }) => Promise<({
+        id: string;
+    } & Record<string, unknown>)[]>;
+    deleteMany: <R extends ResourceKey>(input: Omit<DataDeleteManyInput, "resource"> & {
+        resource: R;
+    }) => Promise<DataDeleteManyOutput>;
+    aggregateMetrics: (input: import("./index").DataAggregateMetricsInput) => Promise<import("./index").DataAggregateMetricsOutput>;
+    relation: {
+        attach: (input: import("./index").DataRelationAttachInput) => Promise<import("./index").DataRelationAttachOutput>;
+        attachMany: (input: import("./index").DataRelationAttachManyInput) => Promise<import("./index").DataRelationAttachManyOutput>;
+        detach: (input: import("./index").DataRelationDetachInput) => Promise<import("./index").DataRelationDetachOutput>;
+        detachMany: (input: import("./index").DataRelationDetachManyInput) => Promise<import("./index").DataRelationDetachManyOutput>;
+        sync: (input: import("./index").DataRelationSyncInput) => Promise<import("./index").DataRelationSyncOutput>;
+    };
+    semanticSearch: (input: import("./index").DataSemanticSearchInput) => Promise<import("./index").DataSemanticSearchOutput>;
+    sum: (input: import("./index").DataSumInput) => Promise<import("./index").DataSumOutput>;
+    validate: (input: import("./index").DataValidateInput) => Promise<import("./index").DataValidateOutput>;
+};
+export {};

package/dist/workflow/errors.d.ts

@@ -0,0 +1,23 @@
+export declare class HostError extends Error {
+    readonly code: string;
+    readonly status: number;
+    readonly details: unknown;
+    readonly failureId: number | null;
+    /**
+     * @param failureId The host's ID for the failure of the call. When the error ends the run, the
+     *   host records that failure, so a run records the failure of the call that it rethrows.
+     */
+    constructor(message: string, code: string, status: number, details: unknown, failureId?: number | null);
+}
+export declare class WorkflowFailure extends Error {
+    readonly status: number;
+    readonly details: unknown;
+    constructor(message: string, status: number, details?: unknown);
+}
+export declare function fail(message: string, options?: {
+    status?: number;
+    details?: unknown;
+}): never;
+export declare function validationError(errors: Record<string, string[]>, options?: {
+    message?: string;
+}): never;