@project-ajax/sdk 0.0.28

package/src/cli/routes.ts

@@ -0,0 +1,43 @@
+import { buildApplication, buildRouteMap, text_en } from "@stricli/core";
+import packageJson from "../../package.json" with { type: "json" };
+import { authCommands } from "./commands/auth.js";
+import { bundleCommands } from "./commands/bundle.js";
+import { capabilitiesCommands } from "./commands/capabilities.js";
+import deploy from "./commands/deploy.js";
+import exec from "./commands/exec.js";
+import { runsCommands } from "./commands/runs.js";
+import { secretsCommands } from "./commands/secrets.js";
+import { TokenNotSetError } from "./config.js";
+
+const routes = buildRouteMap({
+	docs: {
+		brief: "A CLI for the Project Ajax platform",
+	},
+	routes: {
+		auth: authCommands,
+		capabilities: capabilitiesCommands,
+		deploy: deploy,
+		exec: exec,
+		runs: runsCommands,
+		secrets: secretsCommands,
+		bundle: bundleCommands,
+	},
+});
+
+export const app = buildApplication(routes, {
+	name: "workers",
+	versionInfo: {
+		currentVersion: packageJson.version,
+	},
+	localization: {
+		loadText: () => ({
+			...text_en,
+			exceptionWhileRunningCommand(exc: unknown, ansiColor: boolean): string {
+				if (exc instanceof TokenNotSetError) {
+					return exc.message;
+				}
+				return text_en.exceptionWhileRunningCommand(exc, ansiColor);
+			},
+		}),
+	},
+});

package/src/cli/utils/array.ts

@@ -0,0 +1,7 @@
+export function chunkEvery<T>(array: readonly T[], size: number): T[][] {
+	const result: T[][] = [];
+	for (let i = 0; i < array.length; i += size) {
+		result.push(array.slice(i, i + size));
+	}
+	return result;
+}

package/src/cli/utils/string.ts

@@ -0,0 +1,9 @@
+export function pluralize(count: number, word: string, pluralWord?: string) {
+	if (count === 1) {
+		return `${count} ${word}`;
+	}
+	if (!pluralWord) {
+		return `${count} ${word}s`;
+	}
+	return `${count} ${pluralWord}`;
+}

package/src/cli/writer.ts

@@ -0,0 +1,97 @@
+import { createTable, type TableCell, type TableItem } from "@visulima/tabular";
+
+export interface WriterOptions {
+	debugEnabled: boolean;
+}
+
+export interface TableOptions {
+	headers: TableCell[] | TableCell[][];
+	rows: TableCell[][];
+	plain: boolean;
+}
+
+/**
+ * A writer writes messages to standard out and standard error.
+ */
+export class Writer {
+	debugEnabled: boolean;
+
+	constructor(options: WriterOptions) {
+		this.debugEnabled = options.debugEnabled;
+	}
+
+	/**
+	 * Writes a debug message to standard error.
+	 *
+	 * @param args The arguments to write.
+	 */
+	debug(...args: Parameters<typeof console.log>) {
+		if (this.debugEnabled) {
+			args
+				.join(" ")
+				.split("\n")
+				.forEach((line) => {
+					this.writeErr(`[debug] ${line}`);
+				});
+		}
+	}
+
+	/**
+	 * Writes a message to standard out.
+	 *
+	 * @param args The arguments to write.
+	 */
+	writeOut(...args: Parameters<typeof process.stdout.write>) {
+		process.stdout.write(`${args.join(" ")}\n`);
+	}
+
+	/**
+	 * Writes a message to standard error.
+	 *
+	 * @param args The arguments to write.
+	 */
+	writeErr(...args: Parameters<typeof process.stderr.write>) {
+		process.stderr.write(`${args.join(" ")}\n`);
+	}
+
+	/**
+	 * Writes a table to standard out.
+	 *
+	 * @param tableConfig The table configuration.
+	 */
+	writeTableOut(tableConfig: TableOptions) {
+		const content = this.#buildTable(tableConfig);
+		this.writeOut(content);
+	}
+
+	/**
+	 * Writes a table to standard error.
+	 *
+	 * @param tableConfig The table configuration.
+	 */
+	writeTableErr(tableConfig: TableOptions) {
+		const content = this.#buildTable(tableConfig);
+		this.writeErr(content);
+	}
+
+	#buildTable(tableConfig: TableOptions) {
+		if (tableConfig.plain) {
+			return tableConfig.rows
+				.map((row) => {
+					return row
+						.map((cell) => (isTableItem(cell) ? cell.content : cell))
+						.join("\t");
+				})
+				.join("\n");
+		} else {
+			const table = createTable();
+			table.setHeaders(tableConfig.headers);
+			table.addRows(...tableConfig.rows);
+			return table.toString();
+		}
+	}
+}
+
+function isTableItem(cell: TableCell): cell is TableItem {
+	return typeof cell === "object";
+}

package/src/error.ts

@@ -0,0 +1,12 @@
+/**
+ * An error that occurred during the execution of a sync.
+ */
+export class ExecutionError extends Error {
+	readonly cause: unknown;
+
+	constructor(cause: unknown) {
+		super(`Error during sync execution: ${cause}`);
+		this.name = "ExecutionError";
+		this.cause = cause;
+	}
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export { slashCommand } from "./capabilities/slashCommand.js";
+export { sync } from "./capabilities/sync.js";
+export { tool } from "./capabilities/tool.js";

package/src/schema.ts

@@ -0,0 +1,54 @@
+/**
+ * Supported property types for sync schemas.
+ */
+export type PropertyType = "title" | "rich_text" | "url";
+
+/**
+ * Definition of a single property in a sync schema.
+ */
+export type PropertyDefinition = {
+	type: PropertyType;
+};
+
+/**
+ * A schema defining the structure a single property in a data source.
+ */
+export type PropertyConfiguration =
+	| { type: "title" }
+	| { type: "text" }
+	| { type: "url" };
+
+export type Schema<PK extends string> = {
+	dataSourceTitle: string;
+	properties: PropertySchema<PK>;
+};
+
+/**
+ * A schema defining the structure of properties in a data source.
+ */
+export type PropertySchema<PK extends string> = {
+	[PrimaryKey in PK]: PropertyConfiguration;
+} & {
+	[propertyName: string]: PropertyConfiguration;
+};
+
+/**
+ * Creates a title property definition.
+ */
+export function title(): PropertyConfiguration {
+	return { type: "title" };
+}
+
+/**
+ * Creates a rich text property definition.
+ */
+export function richText(): PropertyConfiguration {
+	return { type: "text" };
+}
+
+/**
+ * Creates a URL property definition.
+ */
+export function url(): PropertyConfiguration {
+	return { type: "url" };
+}

package/src/types.ts

@@ -0,0 +1,10 @@
+/**
+ * A text token is a tuple where the first element is the text content
+ * and optional subsequent elements are formatting annotations.
+ */
+type TextToken = [string, ...unknown[]];
+
+/**
+ * A TextValue is an array of text tokens, representing rich text content.
+ */
+export type TextValue = Array<TextToken>;