@contextual-io/cli 0.3.1 → 0.5.0

package/dist/commands/types/list.js

@@ -0,0 +1,129 @@
+/* eslint-disable unicorn/no-array-reduce */
+import { Flags } from "@oclif/core";
+import { BaseCommand } from "../../base.js";
+import { getRegistryApiEndpoint } from "../../utils/endpoints.js";
+import { endTime, startTime } from "../../utils/time.js";
+const flagArrayToParam = (cmd, values) => values
+    .map(_ => _.split("="))
+    .map(([k, v]) => ({ [`${cmd}.${k}`]: v }))
+    .reduce((a, b) => ({ ...a, ...b }), {});
+export default class TypesList extends BaseCommand {
+    static aliases = ["types search"];
+    static args = {};
+    static description = "List types.";
+    static examples = [
+        "<%= config.bin %> <%= command.id %>",
+        "<%= config.bin %> <%= command.id %> --order-by field1:desc",
+        "<%= config.bin %> <%= command.id %> -s field1=value1 -s field2=value2 --include-total",
+    ];
+    static flags = {
+        "exact-search": Flags.string({
+            char: "S",
+            description: "search fields exactly",
+            multiple: true,
+        }),
+        export: Flags.boolean({
+            allowNo: false,
+            char: "e",
+            description: "export data as JSONL",
+        }),
+        from: Flags.string({
+            char: "f",
+            description: "search from",
+            multiple: true,
+        }),
+        "include-total": Flags.boolean({
+            allowNo: false,
+            description: "include total count",
+        }),
+        "order-by": Flags.string({
+            char: "o",
+            description: "order fields",
+            multiple: true,
+        }),
+        "page-size": Flags.integer({
+            description: "number of types per page",
+            max: 250,
+            min: 0,
+        }),
+        "page-token": Flags.string({
+            description: "page token to fetch",
+        }),
+        progress: Flags.boolean({
+            allowNo: false,
+            char: "p",
+            description: "show progress during export",
+        }),
+        search: Flags.string({
+            char: "s",
+            description: "search fields",
+            multiple: true,
+        }),
+        to: Flags.string({
+            char: "t",
+            description: "search to",
+            multiple: true,
+        }),
+    };
+    async run() {
+        const params = {
+            ...(this.flags["page-size"] && { pageSize: this.flags["page-size"] }),
+            ...(this.flags["page-token"] && { pageToken: this.flags["page-token"] }),
+            ...(this.flags["include-total"] && { includeTotal: true }),
+            ...(this.flags["order-by"] && { orderBy: this.flags["order-by"] }),
+            ...flagArrayToParam("search", this.flags.search ?? []),
+            ...flagArrayToParam("exactSearch", this.flags["exact-search"] ?? []),
+            ...flagArrayToParam("from", this.flags.from ?? []),
+            ...flagArrayToParam("to", this.flags.to ?? []),
+        };
+        // eslint-disable-next-line unicorn/consistent-function-scoping
+        const list = (params) => this.fetch(({ silo, tenantId }) => getRegistryApiEndpoint(tenantId, silo) + "/api/v1/$page/types", {
+            body: JSON.stringify(params),
+            headers: {
+                "content-type": "application/json",
+            },
+            method: "POST",
+        });
+        if (this.flags.export) {
+            const pageSize = this.flags["page-size"] ?? 250;
+            params.pageSize = pageSize;
+            params.includeTotal = true;
+            const start = startTime();
+            let page = 1;
+            let nextPageToken;
+            let totalCount = 1;
+            do {
+                if (nextPageToken) {
+                    params.pageToken = nextPageToken;
+                }
+                const xStart = startTime();
+                // eslint-disable-next-line no-await-in-loop
+                const x = await list(params);
+                const xDuration = endTime(xStart);
+                if (x.totalCount) {
+                    totalCount = x.totalCount;
+                }
+                x.items
+                    .map(_ => JSON.stringify(_))
+                    // eslint-disable-next-line unicorn/no-array-for-each
+                    .forEach(_ => this.log(_));
+                nextPageToken = x.nextPageToken;
+                if (this.flags.progress) {
+                    const duration = endTime(start);
+                    const totalPages = Math.ceil(totalCount / pageSize);
+                    const recsPerSec = Math.ceil((page * pageSize) / (duration * 1000));
+                    const eta = (((duration / page) * (totalPages - page)) / 1000).toFixed(2);
+                    process.stderr.write(`\r\u001B[Kexporting types eta: ${eta}s totalCount: ${totalCount} page: ${page}/${totalPages} records/s: ${recsPerSec} lastCall: ${xDuration.toFixed(2)}ms`);
+                }
+                page++;
+            } while (nextPageToken);
+            if (this.flags.progress) {
+                process.stderr.write("\n");
+            }
+        }
+        else {
+            const rv = await list(params);
+            this.logJson(rv);
+        }
+    }
+}

package/dist/commands/types/replace.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from "../../base.js";
+export default class TypesReplace extends BaseCommand<typeof TypesReplace> {
+    static args: {
+        uri: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        "input-file": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        type: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/types/replace.js

@@ -0,0 +1,57 @@
+import { Args, Flags } from "@oclif/core";
+import fs, { createReadStream } from "node:fs";
+import path from "node:path";
+import { BaseCommand } from "../../base.js";
+import { parseUri } from "../../models/uri.js";
+import { getRegistryApiEndpoint } from "../../utils/endpoints.js";
+import { readStreamToEnd } from "../../utils/stream.js";
+export default class TypesReplace extends BaseCommand {
+    static args = {
+        "uri": Args.string({ description: "uri of type" }),
+    };
+    static description = "Replace a type.";
+    static examples = [
+        "<%= config.bin %> <%= command.id %> native-object:my-type --input-file record.json",
+        "<%= config.bin %> <%= command.id %> --type my-type  --input-file record.json",
+    ];
+    static flags = {
+        "input-file": Flags.file({
+            char: "i",
+            default: "-",
+            description: "file to read. can read stdin if value is '-'",
+        }),
+        type: Flags.string({
+            char: "T",
+            description: "type",
+        }),
+    };
+    async run() {
+        const { uri } = this.args;
+        const { type: flagType } = this.flags;
+        let type = flagType;
+        if (uri) {
+            const { type: uriType } = parseUri(uri);
+            type = uriType;
+        }
+        if (!type) {
+            throw new Error("Type not provided");
+        }
+        const inputFile = this.flags["input-file"] === "-"
+            ? "-"
+            : path.resolve(this.flags["input-file"]);
+        if (inputFile && inputFile !== "-" && !fs.existsSync(inputFile)) {
+            throw new Error("File does not exist");
+        }
+        const input = (await readStreamToEnd(inputFile && inputFile !== "-"
+            ? createReadStream(inputFile)
+            : process.stdin)).join("");
+        const replace = (body) => this.fetch(({ silo, tenantId }) => getRegistryApiEndpoint(tenantId, silo) + `/api/v1/types/${type}`, {
+            body,
+            headers: {
+                "content-type": "application/json",
+            },
+            method: "PUT",
+        });
+        this.logJson(await replace(input));
+    }
+}

package/dist/models/uri.js

@@ -1,6 +1,11 @@
 import { z } from "zod";
+import { UrlSafeId } from "./url-safe-id.js";
 export const Uri = z.string().regex(/^native-object:[a-z0-9-]+(\/.+)?/, { error: "URI must match one of the following formats: 'native-object:<type-id>' or 'native-object:<type-id>/<instance-id>'" });
 export const parseUri = (uri) => {
+    const parsedType = UrlSafeId.safeParse(uri);
+    if (parsedType.success) {
+        return { type: parsedType.data };
+    }
     const parsed = Uri.parse(uri);
     const [type, id] = parsed.replace(/^native-object:/, "").split("/");
     return { id, type };

package/dist/models/user-config.d.ts

@@ -23,11 +23,11 @@ export declare const Config: z.ZodObject<{
 }, z.core.$strip>;
 export type Config = z.infer<typeof Config>;
 export declare const CleanConfig: z.ZodObject<{
-    silo: z.ZodEnum<{
+    silo: z.ZodOptional<z.ZodEnum<{
         prod: "prod";
         qa: "qa";
         dev: "dev";
-    }>;
+    }>>;
     tenantId: z.ZodString;
     configId: z.ZodString;
 }, z.core.$strip>;

package/dist/models/user-config.js

@@ -15,6 +15,8 @@ export const Config = z.object({
 export const CleanConfig = Config.pick({
     silo: true,
     tenantId: true,
+}).partial({
+    silo: true,
 }).extend({
     configId: z.string(),
 });

package/dist/utils/endpoints.d.ts

@@ -1,3 +1,4 @@
 import { Silo } from "../models/silo.js";
 export declare const getNativeObjectApiEndpoint: (tenantId: string, silo: Silo) => string;
+export declare const getRegistryApiEndpoint: (tenantId: string, silo: Silo) => string;
 export declare const getAuthApiEndpoint: (tenantId: string, silo: Silo) => string;

package/dist/utils/endpoints.js

@@ -1,2 +1,3 @@
 export const getNativeObjectApiEndpoint = (tenantId, silo) => `https://native-object.${tenantId}.my${silo === "prod" ? "" : `.${silo}`}.contextual.io`;
+export const getRegistryApiEndpoint = (tenantId, silo) => `https://native-object-registry.${tenantId}.my${silo === "prod" ? "" : `.${silo}`}.contextual.io`;
 export const getAuthApiEndpoint = (tenantId, silo) => `https://auth.${tenantId}.my${silo === "prod" ? "" : `.${silo}`}.contextual.io`;