@nyrra/prismantix-cli 0.0.3-next.17 → 0.0.3-next.18

package/dist/api.js

@@ -1,120 +1,248 @@
-import { z } from "zod";
+import { Config, ConfigProvider, Context, Effect, Layer, Predicate, Redacted, Schema, } from "effect";
 import { DEFAULT_API_BASE_URL } from "./constants.js";
-import { CliUserError } from "./errors.js";
-const exportFileSchema = z.object({
-    downloadUrl: z.string().url().nullable().optional(),
-    fileName: z.string(),
-    mimeType: z.string().optional(),
-    rowCount: z.number().optional(),
-    sha256: z.string().optional(),
-    sizeBytes: z.number().optional(),
-    tableName: z.string(),
+const ExportOutputSchema = Schema.Union([
+    Schema.Struct({ kind: Schema.Literal("csv_bundle") }),
+    Schema.Struct({ kind: Schema.Literal("sqlite_seed_script") }),
+]);
+const ManifestFileSchema = Schema.Struct({
+    columns: Schema.optionalKey(Schema.Array(Schema.String)),
+    fileName: Schema.String,
+    mimeType: Schema.optionalKey(Schema.String),
+    rowCount: Schema.optionalKey(Schema.Number),
+    sha256: Schema.optionalKey(Schema.String),
+    sizeBytes: Schema.optionalKey(Schema.Number),
+    storageKey: Schema.optionalKey(Schema.String),
+    tableName: Schema.String,
 });
-const exportCreatedSchema = z.object({
-    clientId: z.string(),
-    exportId: z.string(),
-    manifestUrl: z.string().url().optional(),
-    status: z.literal("queued").optional(),
-    statusUrl: z.string().url().optional(),
+const ExportManifestSchema = Schema.Struct({
+    clientId: Schema.String,
+    completedAt: Schema.optionalKey(Schema.Number),
+    createdAt: Schema.optionalKey(Schema.Number),
+    exportId: Schema.String,
+    files: Schema.Array(ManifestFileSchema),
+    output: ExportOutputSchema,
+    schemaVersion: Schema.optionalKey(Schema.String),
+    totalRows: Schema.Number,
 });
-const exportStatusSchema = z.object({
-    clientId: z.string(),
-    completedAt: z.number().optional(),
-    createdAt: z.number().optional(),
-    errorMessage: z.string().optional(),
-    exportId: z.string(),
-    failedAt: z.number().optional(),
-    files: z.array(exportFileSchema).default([]),
-    manifestUrl: z.string().url().nullable().optional(),
-    startedAt: z.number().optional(),
-    status: z.enum(["queued", "running", "completed", "failed"]),
-    totalFiles: z.number().optional(),
-    totalRows: z.number().optional(),
+const ExportStatusFileSchema = Schema.Struct({
+    downloadUrl: Schema.NullOr(Schema.String),
+    fileName: Schema.String,
+    mimeType: Schema.optionalKey(Schema.String),
+    rowCount: Schema.optionalKey(Schema.Number),
+    sha256: Schema.optionalKey(Schema.String),
+    sizeBytes: Schema.optionalKey(Schema.Number),
+    tableName: Schema.String,
 });
-const manifestFileSchema = exportFileSchema.extend({
-    columns: z.array(z.string()).optional(),
-    storageKey: z.string().optional(),
+const ExportStatusSchema = Schema.Struct({
+    clientId: Schema.String,
+    completedAt: Schema.optionalKey(Schema.Number),
+    createdAt: Schema.optionalKey(Schema.Number),
+    errorMessage: Schema.optionalKey(Schema.String),
+    exportId: Schema.String,
+    failedAt: Schema.optionalKey(Schema.Number),
+    files: Schema.Array(ExportStatusFileSchema),
+    manifestUrl: Schema.optionalKey(Schema.NullOr(Schema.String)),
+    output: ExportOutputSchema,
+    startedAt: Schema.optionalKey(Schema.Number),
+    status: Schema.Literals(["completed", "failed", "queued", "running"]),
+    totalFiles: Schema.optionalKey(Schema.Number),
+    totalRows: Schema.optionalKey(Schema.Number),
 });
-const exportManifestSchema = z
-    .object({
-    clientId: z.string(),
-    completedAt: z.number().optional(),
-    createdAt: z.number().optional(),
-    exportId: z.string(),
-    files: z.array(manifestFileSchema),
-    format: z.literal("csv").optional(),
-    medium: z.literal("csv_bundle").optional(),
-    mode: z.literal("current_client_snapshot").optional(),
-    schemaVersion: z.string().optional(),
-    totalRows: z.number().optional(),
-})
-    .transform((manifest) => ({
-    ...manifest,
-    totalRows: manifest.totalRows ??
-        manifest.files.reduce((sum, file) => sum + (file.rowCount ?? 0), 0),
-}));
-export class PrismantixApiClient {
-    apiBaseUrl;
-    apiKey;
-    fetchImpl;
-    constructor(options) {
-        this.apiBaseUrl = trimTrailingSlash(options.apiBaseUrl ?? DEFAULT_API_BASE_URL);
-        this.apiKey = options.apiKey;
-        this.fetchImpl = options.fetchImpl ?? fetch;
-    }
-    async createExport(clientId) {
-        const response = await this.request(`/v1/clients/${encodeURIComponent(clientId)}/exports`, { method: "POST" });
-        return exportCreatedSchema.parse(await response.json());
-    }
-    async getExportStatus(exportId) {
-        const response = await this.request(`/v1/exports/${encodeURIComponent(exportId)}`);
-        return exportStatusSchema.parse(await response.json());
-    }
-    async getManifest(exportId) {
-        const response = await this.request(`/v1/exports/${encodeURIComponent(exportId)}/manifest`);
-        return exportManifestSchema.parse(await response.json());
-    }
-    async getFile(exportId, tableName) {
-        return this.request(`/v1/exports/${encodeURIComponent(exportId)}/files/${encodeURIComponent(tableName)}`, {}, { accept: "*/*" });
-    }
-    async request(path, init = {}, options = {}) {
-        const headers = new Headers(init.headers);
-        headers.set("Authorization", `Bearer ${this.apiKey}`);
-        headers.set("Accept", options.accept ?? "application/json");
-        const response = await this.fetchImpl(`${this.apiBaseUrl}${path}`, {
-            ...init,
-            headers,
+const ExportCreatedSchema = Schema.Struct({
+    clientId: Schema.String,
+    exportId: Schema.String,
+    status: Schema.Literal("queued"),
+});
+const OntologySummarySchema = Schema.Struct({
+    description: Schema.String,
+    displayName: Schema.String,
+    id: Schema.String,
+    objectCount: Schema.Number,
+});
+const OntologyObjectSummarySchema = Schema.Struct({
+    defaultRecordCount: Schema.NullOr(Schema.Number),
+    description: Schema.String,
+    displayName: Schema.String,
+    generationEligible: Schema.Boolean,
+    owningOntologyId: Schema.String,
+    pluralDisplayName: Schema.String,
+    slug: Schema.String,
+});
+const OntologyObjectDetailSchema = Schema.Struct({
+    ...OntologyObjectSummarySchema.fields,
+    fields: Schema.Array(Schema.Struct({
+        array: Schema.Boolean,
+        description: Schema.String,
+        displayName: Schema.String,
+        enumValues: Schema.optionalKey(Schema.Array(Schema.String)),
+        name: Schema.String,
+        nullable: Schema.Boolean,
+        optional: Schema.Boolean,
+        type: Schema.String,
+    })),
+    generationDependencies: Schema.Array(Schema.String),
+    guidance: Schema.Array(Schema.String),
+    relationships: Schema.Array(Schema.Struct({ field: Schema.String, many: Schema.Boolean, targetObjectSlug: Schema.String })),
+});
+const GenerationStateSchema = Schema.Literals([
+    "queued",
+    "running",
+    "completed",
+    "failed",
+    "canceled",
+]);
+const RecordGenerationCreatedSchema = Schema.Struct({
+    clientId: Schema.String,
+    createdAt: Schema.Number,
+    ontologyId: Schema.String,
+    operationId: Schema.String,
+    status: Schema.Literal("queued"),
+    statusUrl: Schema.String,
+});
+const RecordGenerationStatusSchema = Schema.Struct({
+    canceledAt: Schema.optionalKey(Schema.Number),
+    clientId: Schema.String,
+    completedAt: Schema.optionalKey(Schema.Number),
+    createdAt: Schema.Number,
+    failure: Schema.optionalKey(Schema.Struct({ code: Schema.String, message: Schema.String })),
+    ontologyId: Schema.String,
+    operationId: Schema.String,
+    startedAt: Schema.optionalKey(Schema.Number),
+    status: GenerationStateSchema,
+    steps: Schema.Array(Schema.Struct({
+        issues: Schema.Array(Schema.String),
+        objectSlug: Schema.String,
+        persistedCount: Schema.Number,
+        rejectedCount: Schema.Number,
+        requestedCount: Schema.Number,
+        state: GenerationStateSchema,
+    })),
+    totals: Schema.Struct({
+        objectCount: Schema.Number,
+        persistedCount: Schema.Number,
+        rejectedCount: Schema.Number,
+        requestedCount: Schema.Number,
+    }),
+});
+export class ApiConfigurationError extends Schema.TaggedError()("ApiConfigurationError", { message: Schema.String }) {
+}
+export class ApiHttpError extends Schema.TaggedError()("ApiHttpError", {
+    message: Schema.String,
+    status: Schema.Number,
+}) {
+}
+export class ApiTransportError extends Schema.TaggedError()("ApiTransportError", { message: Schema.String }) {
+}
+export class ApiDecodeError extends Schema.TaggedError()("ApiDecodeError", {
+    message: Schema.String,
+}) {
+}
+export class PrismantixApiClient extends Context.Service()("@prismantix/cli/PrismantixApiClient") {
+}
+const apiConfig = (apiKeyOverride) => Config.all({
+    apiBaseUrl: Config.withDefault(Config.nonEmptyString("PRISMANTIX_API_BASE"), DEFAULT_API_BASE_URL),
+    apiKey: apiKeyOverride
+        ? Config.succeed(Redacted.make(apiKeyOverride))
+        : Config.redacted("PRISMANTIX_API_KEY"),
+});
+export const makePrismantixApiClientLayer = (options = {}) => Layer.effect(PrismantixApiClient, Effect.gen(function* () {
+    const config = yield* apiConfig(options.apiKey).pipe(Effect.mapError(() => new ApiConfigurationError({
+        message: "Set PRISMANTIX_API_KEY before running the CLI.",
+    })));
+    const apiKey = Redacted.value(config.apiKey).trim();
+    if (!apiKey)
+        return yield* new ApiConfigurationError({
+            message: "Set PRISMANTIX_API_KEY before running the CLI.",
+        });
+    const baseUrl = (options.apiBaseUrl ?? config.apiBaseUrl).replace(/\/+$/, "");
+    const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+    const request = (method, path, schema, init = {}, retryTransport = false) => {
+        const effect = requestJson(fetchImpl, `${baseUrl}${path}`, apiKey, method, schema, init);
+        return retryTransport ? retryTransportErrors(effect, 2) : effect;
+    };
+    return PrismantixApiClient.of({
+        cancelRecordGeneration: (operationId) => request("POST", `/v1/record-generations/${encodeURIComponent(operationId)}/cancel`, RecordGenerationStatusSchema, {}, true),
+        createExport: (clientId) => request("POST", `/v1/clients/${encodeURIComponent(clientId)}/exports`, ExportCreatedSchema, { body: JSON.stringify({ output: { kind: "csv_bundle" } }) }),
+        createRecordGeneration: (clientId, ontologyId, idempotencyKey) => request("POST", `/v1/clients/${encodeURIComponent(clientId)}/record-generations`, RecordGenerationCreatedSchema, {
+            body: JSON.stringify({ ontologyId }),
+            headers: { "Idempotency-Key": idempotencyKey },
+        }, true),
+        getExportStatus: (exportId) => request("GET", `/v1/exports/${encodeURIComponent(exportId)}`, ExportStatusSchema, {}, true),
+        getFile: (exportId, tableName) => getExportFile(fetchImpl, baseUrl, apiKey, exportId, tableName),
+        getManifest: (exportId) => request("GET", `/v1/exports/${encodeURIComponent(exportId)}/manifest`, ExportManifestSchema, {}, true),
+        getOntologyObject: (objectSlug) => request("GET", `/v1/objects/${encodeURIComponent(objectSlug)}`, OntologyObjectDetailSchema, {}, true),
+        getRecordGeneration: (operationId) => request("GET", `/v1/record-generations/${encodeURIComponent(operationId)}`, RecordGenerationStatusSchema, {}, true),
+        listOntologies: () => request("GET", "/v1/ontologies", Schema.Array(OntologySummarySchema), {}, true),
+        listOntologyObjects: (ontologyId) => request("GET", `/v1/ontologies/${encodeURIComponent(ontologyId)}/objects`, Schema.Array(OntologyObjectSummarySchema), {}, true),
+    });
+}).pipe(Effect.provide(ConfigProvider.layer(options.configProvider ?? ConfigProvider.fromEnv()))));
+function requestJson(fetchImpl, url, apiKey, method, schema, init) {
+    return Effect.gen(function* () {
+        const response = yield* Effect.tryPromise({
+            try: (signal) => fetchImpl(url, {
+                ...init,
+                headers: {
+                    Accept: "application/json",
+                    Authorization: `Bearer ${apiKey}`,
+                    "Content-Type": "application/json",
+                    ...init.headers,
+                },
+                method,
+                signal,
+            }),
+            catch: (cause) => new ApiTransportError({ message: cause instanceof Error ? cause.message : String(cause) }),
         });
-        if (response.ok) {
-            return response;
-        }
-        throw new CliUserError(codeForStatus(response.status), await readApiError(response));
-    }
+        if (!response.ok)
+            return yield* httpError(response);
+        const payload = yield* Effect.tryPromise({
+            try: () => response.json(),
+            catch: (cause) => new ApiDecodeError({ message: cause instanceof Error ? cause.message : String(cause) }),
+        });
+        return yield* Schema.decodeUnknownEffect(schema)(payload).pipe(Effect.mapError((error) => new ApiDecodeError({ message: String(error) })));
+    });
 }
-async function readApiError(response) {
-    try {
-        const payload = (await response.json());
-        return (payload.message ?? payload.error ?? `API returned ${response.status}.`);
-    }
-    catch {
-        return `API returned ${response.status}.`;
-    }
+function retryTransportErrors(effect, remainingRetries) {
+    return effect.pipe(Effect.catchTag("ApiTransportError", (error) => remainingRetries > 0
+        ? retryTransportErrors(effect, remainingRetries - 1)
+        : Effect.fail(error)));
 }
-function codeForStatus(status) {
-    if (status === 401) {
-        return "unauthorized";
-    }
-    if (status === 403) {
-        return "forbidden";
-    }
-    if (status === 404) {
-        return "not_found";
-    }
-    if (status === 409) {
-        return "export_not_ready";
-    }
-    return "api_error";
+function httpError(response) {
+    return Effect.gen(function* () {
+        const payload = yield* Effect.promise(async () => {
+            try {
+                return (await response.json());
+            }
+            catch {
+                return undefined;
+            }
+        });
+        const message = Predicate.isObject(payload) && typeof payload.message === "string"
+            ? payload.message
+            : `API returned ${response.status}.`;
+        return yield* new ApiHttpError({ message, status: response.status });
+    });
 }
-function trimTrailingSlash(value) {
-    return value.replace(/\/+$/, "");
+function getExportFile(fetchImpl, baseUrl, apiKey, exportId, tableName) {
+    return Effect.gen(function* () {
+        const redirect = yield* Effect.tryPromise({
+            try: (signal) => fetchImpl(`${baseUrl}/v1/exports/${encodeURIComponent(exportId)}/files/${encodeURIComponent(tableName)}`, {
+                headers: { Accept: "application/json", Authorization: `Bearer ${apiKey}` },
+                redirect: "manual",
+                signal,
+            }),
+            catch: (cause) => new ApiTransportError({ message: cause instanceof Error ? cause.message : String(cause) }),
+        });
+        if (redirect.status >= 400)
+            return yield* httpError(redirect);
+        const location = redirect.headers.get("location");
+        if (!location)
+            return yield* new ApiDecodeError({ message: "API returned a redirect without a location." });
+        const response = yield* Effect.tryPromise({
+            try: (signal) => fetchImpl(location, { headers: { Accept: "*/*" }, signal }),
+            catch: (cause) => new ApiTransportError({ message: cause instanceof Error ? cause.message : String(cause) }),
+        });
+        if (!response.ok)
+            return yield* httpError(response);
+        return response;
+    });
 }

package/dist/command-support.d.ts

@@ -0,0 +1,13 @@
+import type { Command } from "@oclif/core";
+import type { Effect } from "effect";
+import { PrismantixApiClient } from "./api.js";
+export declare const apiFlags: {
+    "api-base": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+};
+export declare const runApiEffect: <A, E>(effect: Effect.Effect<A, E, PrismantixApiClient>, apiBaseUrl?: string) => Promise<A>;
+export declare function printResult(command: Command, result: unknown, json: boolean, printHuman: () => void): void;
+export declare function failCommand(command: Command, error: unknown, json: boolean): never;
+export declare function requireValue(value: string | undefined, flagName: string): string;
+export declare function validatePositiveInteger(value: number | undefined, flagName: string): void;
+//# sourceMappingURL=command-support.d.ts.map

package/dist/command-support.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-support.d.ts","sourceRoot":"","sources":["../src/command-support.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AACrC,OAAO,EAAgC,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAI7E,eAAO,MAAM,QAAQ;;;CAQpB,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,CAAC,EAAE,CAAC,EAChC,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,mBAAmB,CAAC,EAChD,aAAa,MAAM,eACmD,CAAC;AAExE,wBAAgB,WAAW,CAC1B,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,OAAO,EACf,IAAI,EAAE,OAAO,EACb,UAAU,EAAE,MAAM,IAAI,QAOtB;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,GAAG,KAAK,CASlF;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,MAAM,UAIvE;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,MAAM,QAGlF"}

package/dist/command-support.js

@@ -0,0 +1,40 @@
+import { Flags } from "@oclif/core";
+import { makePrismantixApiClientLayer } from "./api.js";
+import { CliUserError, toCliUserError } from "./errors.js";
+import { runCliEffect } from "./runtime.js";
+export const apiFlags = {
+    "api-base": Flags.string({
+        description: "PrismantiX API base URL.",
+        env: "PRISMANTIX_API_BASE",
+    }),
+    json: Flags.boolean({
+        description: "Print one machine-readable JSON result to stdout.",
+    }),
+};
+export const runApiEffect = (effect, apiBaseUrl) => runCliEffect(effect, makePrismantixApiClientLayer({ apiBaseUrl }));
+export function printResult(command, result, json, printHuman) {
+    if (json) {
+        command.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    printHuman();
+}
+export function failCommand(command, error, json) {
+    const userError = toCliUserError(error);
+    if (json) {
+        command.logToStderr(JSON.stringify({ code: userError.code, error: userError.message, ok: false }));
+        command.exit(userError.exitCode);
+    }
+    command.error(userError.message, { code: userError.code, exit: userError.exitCode });
+}
+export function requireValue(value, flagName) {
+    const normalized = value?.trim();
+    if (normalized)
+        return normalized;
+    throw new CliUserError("invalid_argument", `${flagName} is required.`);
+}
+export function validatePositiveInteger(value, flagName) {
+    if (value !== undefined && Number.isInteger(value) && value > 0)
+        return;
+    throw new CliUserError("invalid_argument", `${flagName} must be a positive integer.`);
+}

package/dist/commands/object/details.d.ts

@@ -0,0 +1,13 @@
+import { Command } from "@oclif/core";
+export default class ObjectDetails extends Command {
+    static args: {
+        objectSlug: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static flags: {
+        "api-base": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}
+//# sourceMappingURL=details.d.ts.map

package/dist/commands/object/details.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"details.d.ts","sourceRoot":"","sources":["../../../src/commands/object/details.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,OAAO,EAAE,MAAM,aAAa,CAAC;AAW5C,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,OAAO;IACjD,OAAgB,IAAI;;MAAmD;IACvE,OAAgB,WAAW,SAA2D;IACtF,OAAgB,KAAK;;;MAAY;IAEpB,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAqBjC"}

package/dist/commands/object/details.js

@@ -0,0 +1,28 @@
+import { Args, Command } from "@oclif/core";
+import { Effect } from "effect";
+import { PrismantixApiClient } from "../../api.js";
+import { apiFlags, failCommand, printResult, requireValue, runApiEffect, } from "../../command-support.js";
+export default class ObjectDetails extends Command {
+    static args = { objectSlug: Args.string({ required: true }) };
+    static description = "Show the authored public details for one object slug.";
+    static flags = apiFlags;
+    async run() {
+        const { args, flags } = await this.parse(ObjectDetails);
+        try {
+            const objectSlug = requireValue(args.objectSlug, "objectSlug");
+            const result = await runApiEffect(Effect.gen(function* () {
+                const api = yield* PrismantixApiClient;
+                return yield* api.getOntologyObject(objectSlug);
+            }), flags["api-base"]);
+            printResult(this, result, flags.json, () => {
+                this.log(`${result.displayName} (${result.slug})`);
+                this.log(result.description);
+                this.log(`Owning ontology: ${result.owningOntologyId}`);
+                this.log(`Fields: ${result.fields.length}`);
+            });
+        }
+        catch (error) {
+            failCommand(this, error, flags.json);
+        }
+    }
+}

package/dist/commands/object/list.d.ts

@@ -0,0 +1,13 @@
+import { Command } from "@oclif/core";
+export default class ObjectList extends Command {
+    static args: {
+        ontologyId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static flags: {
+        "api-base": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}
+//# sourceMappingURL=list.d.ts.map

package/dist/commands/object/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../src/commands/object/list.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,OAAO,EAAE,MAAM,aAAa,CAAC;AAW5C,MAAM,CAAC,OAAO,OAAO,UAAW,SAAQ,OAAO;IAC9C,OAAgB,IAAI;;MAAmD;IACvE,OAAgB,WAAW,SAA6D;IACxF,OAAgB,KAAK;;;MAAY;IAEpB,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAoBjC"}

package/dist/commands/object/list.js

@@ -0,0 +1,27 @@
+import { Args, Command } from "@oclif/core";
+import { Effect } from "effect";
+import { PrismantixApiClient } from "../../api.js";
+import { apiFlags, failCommand, printResult, requireValue, runApiEffect, } from "../../command-support.js";
+export default class ObjectList extends Command {
+    static args = { ontologyId: Args.string({ required: true }) };
+    static description = "List the complete effective object set for an ontology.";
+    static flags = apiFlags;
+    async run() {
+        const { args, flags } = await this.parse(ObjectList);
+        try {
+            const ontologyId = requireValue(args.ontologyId, "ontologyId");
+            const result = await runApiEffect(Effect.gen(function* () {
+                const api = yield* PrismantixApiClient;
+                return yield* api.listOntologyObjects(ontologyId);
+            }), flags["api-base"]);
+            printResult(this, result, flags.json, () => {
+                for (const object of result) {
+                    this.log(`${object.slug}\t${object.displayName}\t${object.owningOntologyId}`);
+                }
+            });
+        }
+        catch (error) {
+            failCommand(this, error, flags.json);
+        }
+    }
+}

package/dist/commands/ontology/list.d.ts

@@ -0,0 +1,10 @@
+import { Command } from "@oclif/core";
+export default class OntologyList extends Command {
+    static description: string;
+    static flags: {
+        "api-base": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}
+//# sourceMappingURL=list.d.ts.map

package/dist/commands/ontology/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../src/commands/ontology/list.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAKtC,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,OAAO;IAChD,OAAgB,WAAW,SAAgD;IAC3E,OAAgB,KAAK;;;MAAY;IAEpB,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAmBjC"}

package/dist/commands/ontology/list.js

@@ -0,0 +1,25 @@
+import { Command } from "@oclif/core";
+import { Effect } from "effect";
+import { PrismantixApiClient } from "../../api.js";
+import { apiFlags, failCommand, printResult, runApiEffect } from "../../command-support.js";
+export default class OntologyList extends Command {
+    static description = "List every registered PrismantiX ontology.";
+    static flags = apiFlags;
+    async run() {
+        const { flags } = await this.parse(OntologyList);
+        try {
+            const result = await runApiEffect(Effect.gen(function* () {
+                const api = yield* PrismantixApiClient;
+                return yield* api.listOntologies();
+            }), flags["api-base"]);
+            printResult(this, result, flags.json, () => {
+                for (const ontology of result) {
+                    this.log(`${ontology.id}\t${ontology.displayName}\t${ontology.objectCount} objects`);
+                }
+            });
+        }
+        catch (error) {
+            failCommand(this, error, flags.json);
+        }
+    }
+}

package/dist/commands/records/cancel.d.ts

@@ -0,0 +1,13 @@
+import { Command } from "@oclif/core";
+export default class RecordsCancel extends Command {
+    static args: {
+        operationId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static flags: {
+        "api-base": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}
+//# sourceMappingURL=cancel.d.ts.map

package/dist/commands/records/cancel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cancel.d.ts","sourceRoot":"","sources":["../../../src/commands/records/cancel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,OAAO,EAAE,MAAM,aAAa,CAAC;AAU5C,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,OAAO;IACjD,OAAgB,IAAI;;MAAoD;IACxE,OAAgB,WAAW,SAAuD;IAClF,OAAgB,KAAK;;;MAAY;IAEpB,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAYjC"}

package/dist/commands/records/cancel.js

@@ -0,0 +1,21 @@
+import { Args, Command } from "@oclif/core";
+import { apiFlags, failCommand, printResult, requireValue, runApiEffect, } from "../../command-support.js";
+import { cancelRecordGeneration } from "../../generation.js";
+export default class RecordsCancel extends Command {
+    static args = { operationId: Args.string({ required: true }) };
+    static description = "Best-effort cancel a record-generation operation.";
+    static flags = apiFlags;
+    async run() {
+        const { args, flags } = await this.parse(RecordsCancel);
+        try {
+            const operationId = requireValue(args.operationId, "operation-id");
+            const result = await runApiEffect(cancelRecordGeneration(operationId), flags["api-base"]);
+            printResult(this, result, flags.json, () => {
+                this.log(`Record generation ${result.operationId}: ${result.status}`);
+            });
+        }
+        catch (error) {
+            failCommand(this, error, flags.json);
+        }
+    }
+}

package/dist/commands/records/generate.d.ts

@@ -0,0 +1,15 @@
+import { Command } from "@oclif/core";
+export default class RecordsGenerate extends Command {
+    static description: string;
+    static flags: {
+        client: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        ontology: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        "poll-interval": import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        timeout: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        wait: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "api-base": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}
+//# sourceMappingURL=generate.d.ts.map

package/dist/commands/records/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../src/commands/records/generate.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAS,MAAM,aAAa,CAAC;AAa7C,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,OAAO;IACnD,OAAgB,WAAW,SAAuE;IAClG,OAAgB,KAAK;;;;;;;;MAiBnB;IAEW,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CA8BjC"}