@contextual-io/cli 0.1.1 → 0.1.3

package/dist/commands/records/query.js

@@ -0,0 +1,134 @@
+import { Args, Flags } from "@oclif/core";
+import fs, { createReadStream } from "node:fs";
+import path from "node:path";
+import { parseUri } from "../../models/uri.js";
+import { getNativeObjectApiEndpoint } from "../../utils/endpoints.js";
+import { readStreamToEnd } from "../../utils/stream.js";
+import { endTime, startTime } from "../../utils/time.js";
+import { BaseCommand } from "../base.js";
+export default class RecordsQuery extends BaseCommand {
+    static args = {
+        "uri": Args.string({ description: "uri of type" }),
+    };
+    static description = "query records";
+    static examples = [
+        "<%= config.bin %> <%= command.id %> native-object:my-type",
+        "<%= config.bin %> <%= command.id %> --type my-type --query-file query.json",
+        "<%= config.bin %> <%= command.id %> --type my-type --order-by field1:desc --query-file query.json",
+        "<%= config.bin %> <%= command.id %> --type my-type --include-total --query-file query.json",
+    ];
+    static flags = {
+        export: Flags.boolean({
+            allowNo: false,
+            char: "e",
+            description: "export data as JSONL",
+        }),
+        "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 records 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",
+        }),
+        "query-file": Flags.file({
+            char: "q",
+            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 queryFile = this.flags["query-file"] === "-"
+            ? "-"
+            : path.resolve(this.flags["query-file"]);
+        if (queryFile && queryFile !== "-" && !fs.existsSync(queryFile)) {
+            throw new Error("File does not exist");
+        }
+        const query = JSON.parse((await readStreamToEnd(queryFile && queryFile !== "-"
+            ? createReadStream(queryFile)
+            : process.stdin)).join(""));
+        const params = {
+            query,
+            ...(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"] }),
+        };
+        const runQuery = (params) => this.fetch(({ silo, tenantId }) => getNativeObjectApiEndpoint(tenantId, silo) + `/api/v1/$query/${type}`, {
+            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 runQuery(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 ${type} 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 runQuery(params);
+            this.logJson(rv);
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+import { BaseCommand } from "../base.js";
+export default class RecordsReplace extends BaseCommand<typeof RecordsReplace> {
+    static args: {
+        uri: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        id: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "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/records/replace.js

@@ -0,0 +1,69 @@
+import { Args, Flags } from "@oclif/core";
+import fs, { createReadStream } from "node:fs";
+import path from "node:path";
+import { parseUri } from "../../models/uri.js";
+import { getNativeObjectApiEndpoint } from "../../utils/endpoints.js";
+import { readStreamToEnd } from "../../utils/stream.js";
+import { BaseCommand } from "../base.js";
+export default class RecordsReplace extends BaseCommand {
+    static args = {
+        "uri": Args.string({ description: "uri of record" }),
+    };
+    static description = "replace a record";
+    static examples = [
+        "<%= config.bin %> <%= command.id %> native-object:my-type/instance-1 --input-file record.json",
+        "<%= config.bin %> <%= command.id %> native-object:my-type --id instance-1 --input-file record.json",
+        "<%= config.bin %> <%= command.id %> --type my-type --id instance-1 --input-file record.json",
+    ];
+    static flags = {
+        id: Flags.string({
+            char: "i",
+            description: "id",
+        }),
+        "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 { id: flagId, type: flagType } = this.flags;
+        let type = flagType;
+        let lookup = flagId;
+        if (uri) {
+            const { id, type: uriType } = parseUri(uri);
+            type = uriType;
+            if (id) {
+                lookup = id;
+            }
+        }
+        if (!type) {
+            throw new Error("Type not provided");
+        }
+        if (!lookup) {
+            throw new Error("Id 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 }) => getNativeObjectApiEndpoint(tenantId, silo) + `/api/v1/${type}/${lookup}`, {
+            body,
+            headers: {
+                "content-type": "application/json",
+            },
+            method: "PUT",
+        });
+        this.logJson(await replace(input));
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from "@oclif/core";

package/dist/index.js

@@ -0,0 +1 @@
+export { run } from "@oclif/core";

package/dist/models/cli-configuration.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export declare const CliConfiguration: z.ZodObject<{
+    auth: z.ZodObject<{
+        audience: z.ZodString;
+        clientId: z.ZodString;
+        domain: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type CliConfiguration = z.infer<typeof CliConfiguration>;

package/dist/models/cli-configuration.js

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export const CliConfiguration = z.object({
+    auth: z.object({
+        audience: z.string(),
+        clientId: z.string(),
+        domain: z.string(),
+    }),
+});

package/dist/models/errors.d.ts

@@ -0,0 +1,5 @@
+export declare class HttpError extends Error {
+    readonly response: unknown;
+    readonly status: number;
+    constructor(message: string, response: unknown, status: number);
+}

package/dist/models/errors.js

@@ -0,0 +1,14 @@
+export class HttpError extends Error {
+    response;
+    status;
+    constructor(message, response, status) {
+        const msg = [
+            message,
+            `status ${status}`,
+            typeof response === "string" ? response : JSON.stringify(response, null, 2),
+        ].join("\n");
+        super(msg);
+        this.response = response;
+        this.status = status;
+    }
+}

package/dist/models/silo.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export declare const Silo: z.ZodEnum<{
+    prod: "prod";
+    qa: "qa";
+    dev: "dev";
+}>;
+export type Silo = z.infer<typeof Silo>;

package/dist/models/silo.js

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export const Silo = z.enum(["prod", "qa", "dev"]);

package/dist/models/uri.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export declare const Uri: z.ZodString;
+export type Uri = z.infer<typeof Uri>;
+export declare const parseUri: (uri: string) => {
+    id?: string;
+    type: string;
+};

package/dist/models/uri.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export const Uri = z.string().regex(/^native-object:[a-z0-9-]+(\/.+)?/);
+export const parseUri = (uri) => {
+    const parsed = Uri.parse(uri);
+    const [type, id] = parsed.replace(/^native-object:/, "").split("/");
+    return { id, type };
+};

package/dist/models/url-safe-id.d.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+export declare const UrlSafeId: z.ZodString;
+export type UrlSafeId = z.infer<typeof UrlSafeId>;

package/dist/models/url-safe-id.js

@@ -0,0 +1,4 @@
+import { z } from "zod";
+export const UrlSafeId = z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, {
+    message: "this field must begin with a lowercase alphanumeric character, and can only contain lowercase alphanumeric characters and dashes",
+});

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

@@ -0,0 +1,54 @@
+import { z } from "zod";
+export declare const AuthConfig: z.ZodObject<{
+    bearerToken: z.ZodString;
+    expiresAt: z.ZodString;
+    refreshToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AuthConfig = z.infer<typeof AuthConfig>;
+export declare const Config: z.ZodObject<{
+    silo: z.ZodEnum<{
+        prod: "prod";
+        qa: "qa";
+        dev: "dev";
+    }>;
+    tenantId: z.ZodString;
+    auth: z.ZodObject<{
+        audience: z.ZodString;
+        clientId: z.ZodString;
+        domain: z.ZodString;
+    }, z.core.$strip>;
+    bearerToken: z.ZodOptional<z.ZodString>;
+    expiresAt: z.ZodOptional<z.ZodString>;
+    refreshToken: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+export type Config = z.infer<typeof Config>;
+export declare const CleanConfig: z.ZodObject<{
+    silo: z.ZodEnum<{
+        prod: "prod";
+        qa: "qa";
+        dev: "dev";
+    }>;
+    tenantId: z.ZodString;
+    configId: z.ZodString;
+}, z.core.$strip>;
+export type CleanConfig = z.infer<typeof CleanConfig>;
+export declare const UserConfig: z.ZodObject<{
+    configs: z.ZodRecord<z.ZodString, z.ZodObject<{
+        silo: z.ZodEnum<{
+            prod: "prod";
+            qa: "qa";
+            dev: "dev";
+        }>;
+        tenantId: z.ZodString;
+        auth: z.ZodObject<{
+            audience: z.ZodString;
+            clientId: z.ZodString;
+            domain: z.ZodString;
+        }, z.core.$strip>;
+        bearerToken: z.ZodOptional<z.ZodString>;
+        expiresAt: z.ZodOptional<z.ZodString>;
+        refreshToken: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strip>>;
+    current: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type UserConfig = z.infer<typeof UserConfig>;

package/dist/models/user-config.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { CliConfiguration } from "./cli-configuration.js";
+import { Silo } from "./silo.js";
+import { UrlSafeId } from "./url-safe-id.js";
+export const AuthConfig = z.object({
+    bearerToken: z.string(),
+    expiresAt: z.string(),
+    refreshToken: z.string().optional(),
+});
+export const Config = z.object({
+    silo: Silo,
+    tenantId: UrlSafeId,
+}).extend(CliConfiguration.shape)
+    .extend(AuthConfig.partial().shape);
+export const CleanConfig = Config.pick({
+    silo: true,
+    tenantId: true,
+}).extend({
+    configId: z.string(),
+});
+export const UserConfig = z.object({
+    configs: z.record(UrlSafeId, Config),
+    current: UrlSafeId.optional(),
+});

package/dist/utils/auth.d.ts

@@ -0,0 +1,6 @@
+import { CliConfiguration } from "../models/cli-configuration.js";
+import { Silo } from "../models/silo.js";
+import { AuthConfig } from "../models/user-config.js";
+export declare const codeExchange: ({ audience, clientId, domain }: CliConfiguration["auth"]) => Promise<AuthConfig>;
+export declare const rehydrateToken: ({ clientId, domain }: CliConfiguration["auth"], refreshToken: string) => Promise<AuthConfig>;
+export declare const getUserProfile: (tenantId: string, silo: Silo, bearerToken: string) => Promise<any>;

package/dist/utils/auth.js

@@ -0,0 +1,101 @@
+/* eslint-disable camelcase */
+import fetch from "cross-fetch";
+import open from "open";
+import { z } from "zod";
+import { AuthConfig } from "../models/user-config.js";
+import { getAuthApiEndpoint } from "./endpoints.js";
+const scope = "offline_access openid";
+const TokenResponse = z.object({
+    access_token: z.string(),
+    expires_in: z.number(),
+    refresh_token: z.string().optional(),
+});
+const parseTokenResponse = (tokenJson) => {
+    const { access_token, expires_in, refresh_token } = TokenResponse.parse(tokenJson);
+    const expiresAt = new Date();
+    expiresAt.setUTCSeconds(expiresAt.getUTCSeconds() + expires_in);
+    return AuthConfig.parse({
+        bearerToken: access_token,
+        expiresAt: expiresAt.toISOString(),
+        refreshToken: refresh_token,
+    });
+};
+export const codeExchange = async ({ audience, clientId, domain }) => {
+    const authEndpoint = `https://${domain}`;
+    const codeRsp = await fetch(`${authEndpoint}/oauth/device/code`, {
+        body: new URLSearchParams({
+            audience,
+            client_id: clientId,
+            scope,
+        }).toString(),
+        headers: {
+            "content-type": "application/x-www-form-urlencoded",
+        },
+        method: "POST",
+    });
+    const codeJson = await codeRsp.json();
+    const { device_code, interval, verification_uri_complete } = codeJson;
+    console.log("We've launched your web browser to complete the login process.");
+    console.log("Verification code: %s", device_code);
+    console.log();
+    console.log("Waiting for login to complete...");
+    await open(`${verification_uri_complete}&audience=${audience}`);
+    while (true) {
+        // eslint-disable-next-line no-await-in-loop
+        const tokenRsp = await fetch(`${authEndpoint}/oauth/token`, {
+            body: new URLSearchParams({
+                audience,
+                client_id: clientId,
+                device_code,
+                grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+            }),
+            headers: {
+                "content-type": "application/x-www-form-urlencoded",
+            },
+            method: "POST",
+        });
+        // eslint-disable-next-line no-await-in-loop
+        const tokenJson = await tokenRsp.json();
+        if ("error" in tokenJson) {
+            switch (tokenJson.error) {
+                case "authorization_pending": {
+                    break;
+                }
+                default: {
+                    console.log("error", tokenJson);
+                }
+            }
+            // eslint-disable-next-line no-await-in-loop
+            await new Promise(resolve => { setTimeout(resolve, interval * 1000); });
+        }
+        else {
+            const rv = parseTokenResponse(tokenJson);
+            return rv;
+        }
+    }
+};
+export const rehydrateToken = async ({ clientId, domain }, refreshToken) => {
+    const refreshRsp = await fetch(`https://${domain}/oauth/token`, {
+        body: new URLSearchParams({
+            client_id: clientId,
+            grant_type: "refresh_token",
+            refresh_token: refreshToken,
+            scope,
+        }).toString(),
+        headers: {
+            "content-type": "application/x-www-form-urlencoded",
+        },
+        method: "POST",
+    });
+    const tokenJson = await refreshRsp.json();
+    return parseTokenResponse(tokenJson);
+};
+export const getUserProfile = async (tenantId, silo, bearerToken) => {
+    const rsp = await fetch(getAuthApiEndpoint(tenantId, silo) + "/api/v1/me/profile", {
+        headers: {
+            authorization: `Bearer ${bearerToken}`,
+        },
+        method: "GET",
+    });
+    return rsp.json();
+};

package/dist/utils/cli-configuration.d.ts

@@ -0,0 +1,3 @@
+import { CliConfiguration } from "../models/cli-configuration.js";
+import { Silo } from "../models/silo.js";
+export declare const getCliConfiguration: (tenantId: string, silo: Silo) => Promise<CliConfiguration>;

package/dist/utils/cli-configuration.js

@@ -0,0 +1,19 @@
+import fetch from "cross-fetch";
+import { CliConfiguration } from "../models/cli-configuration.js";
+import { getNativeObjectApiEndpoint } from "./endpoints.js";
+export const getCliConfiguration = async (tenantId, silo) => {
+    const url = getNativeObjectApiEndpoint(tenantId, silo) + "/.well-known/cli-configuration";
+    let rsp;
+    try {
+        rsp = await fetch(url, {
+            method: "GET",
+        });
+        if (!rsp.ok)
+            throw new Error("not ok");
+    }
+    catch {
+        throw new Error(`unable to fetch cli configuration: ${JSON.stringify({ silo, tenantId })}`);
+    }
+    const val = await rsp.json();
+    return CliConfiguration.parse(val);
+};

package/dist/utils/endpoints.d.ts

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

package/dist/utils/endpoints.js

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

package/dist/utils/stream.d.ts

@@ -0,0 +1,3 @@
+import { Readable, Transform } from "node:stream";
+export declare const readStreamToEnd: <T = unknown>(stream: Readable) => Promise<T[]>;
+export declare const mapStream: <I, O = I>(fn: (t: I) => Promise<O>) => Transform;

package/dist/utils/stream.js

@@ -0,0 +1,21 @@
+import { Transform } from "node:stream";
+export const readStreamToEnd = (stream) => {
+    const chunks = [];
+    return new Promise((resolve, reject) => {
+        stream.on("data", chunk => chunks.push(chunk));
+        stream.on("error", err => reject(err));
+        stream.on("end", () => resolve(chunks));
+    });
+};
+export const mapStream = (fn) => new Transform({
+    objectMode: true,
+    async transform(chunk, _, callback) {
+        try {
+            const xxx = fn(chunk);
+            callback(null, (xxx instanceof Promise) ? await xxx : xxx);
+        }
+        catch (error) {
+            callback(error instanceof Error ? error : new Error(`${error}`));
+        }
+    },
+});

package/dist/utils/time.d.ts

@@ -0,0 +1,2 @@
+export declare const startTime: () => [number, number];
+export declare const endTime: (t: [number, number]) => number;

package/dist/utils/time.js

@@ -0,0 +1,5 @@
+export const startTime = () => process.hrtime();
+export const endTime = (t) => {
+    const time = process.hrtime(t);
+    return time[0] * 1e3 + time[1] / 1e6;
+};