@ariestools/cli 0.1.8 → 0.1.9

package/dist/node/datalake.d.ts

@@ -0,0 +1,100 @@
+/** Programmatic datalake client API shipped with @ariestools/cli (bundled). */
+
+export type AuthTokenSource = string | (() => string | Promise<string>)
+export type PayloadsAuthTokenSource = AuthTokenSource
+
+export interface StoredCredentials {
+  authToken: string
+  baseUrl: string
+  userId?: string
+}
+
+export interface WalletJwtCredentials {
+  baseUrl: string
+  walletJwt: true
+  userId?: string
+}
+
+export interface CreateDatalakeClientOptions {
+  authToken?: AuthTokenSource
+  baseUrl?: string
+  driver?: 'local' | 'rest'
+}
+
+export interface RestDatalakeClientOptions {
+  authToken: AuthTokenSource
+  baseUrl: string
+  fetchImpl?: typeof fetch
+}
+
+export interface RestPayloadsClientOptions {
+  authToken: PayloadsAuthTokenSource
+  baseUrl: string
+  datalakeId: string
+  fetchImpl?: typeof fetch
+}
+
+export interface InsertPayloadsResult {
+  duplicates?: number
+  payloads: unknown[]
+  rejected?: string[]
+}
+
+export interface PayloadsClient {
+  clear(): Promise<{ removed: number }>
+  delete(hash: string): Promise<void>
+  get(hash: string): Promise<unknown>
+  getMany(hashes: string[]): Promise<unknown[]>
+  insert(payloads: unknown[]): Promise<InsertPayloadsResult>
+  next(options?: { cursor?: string; limit?: number }): Promise<{ nextCursor?: string; payloads: unknown[] }>
+  usage(): Promise<{ datalakeId: string; payloadCount: number }>
+}
+
+export interface DatalakeClient {
+  create(body: unknown): Promise<unknown>
+  destroy(id: string): Promise<void>
+  get(id: string): Promise<unknown>
+  grant(id: string, body: unknown): Promise<unknown>
+  list(): Promise<unknown[]>
+  mintToken(id: string, body?: unknown): Promise<unknown>
+  revoke(id: string, body: unknown): Promise<void>
+}
+
+export declare function createDatalakeClient(options?: CreateDatalakeClientOptions): DatalakeClient
+export declare class LocalDatalakeClient implements DatalakeClient {
+  create(body: unknown): Promise<unknown>
+  destroy(id: string): Promise<void>
+  get(id: string): Promise<unknown>
+  grant(id: string, body: unknown): Promise<unknown>
+  list(): Promise<unknown[]>
+  mintToken(id: string, body?: unknown): Promise<unknown>
+  revoke(id: string, body: unknown): Promise<void>
+}
+export declare class RestDatalakeClient implements DatalakeClient {
+  constructor(options: RestDatalakeClientOptions)
+  create(body: unknown): Promise<unknown>
+  destroy(id: string): Promise<void>
+  get(id: string): Promise<unknown>
+  grant(id: string, body: unknown): Promise<unknown>
+  list(): Promise<unknown[]>
+  mintToken(id: string, body?: unknown): Promise<unknown>
+  revoke(id: string, body: unknown): Promise<void>
+}
+export declare class RestPayloadsClient implements PayloadsClient {
+  constructor(options: RestPayloadsClientOptions)
+  clear(): Promise<{ removed: number }>
+  delete(hash: string): Promise<void>
+  get(hash: string): Promise<unknown>
+  getMany(hashes: string[]): Promise<unknown[]>
+  insert(payloads: unknown[]): Promise<InsertPayloadsResult>
+  next(options?: { cursor?: string; limit?: number }): Promise<{ nextCursor?: string; payloads: unknown[] }>
+  usage(): Promise<{ datalakeId: string; payloadCount: number }>
+}
+
+export declare function loadCredentials(): StoredCredentials | WalletJwtCredentials | undefined
+export declare function saveCredentials(credentials: StoredCredentials | WalletJwtCredentials): void
+export declare function clearCredentials(): void
+export declare function getCredentialsLocation(): string
+export declare function getDefaultDatalake(): string | undefined
+export declare function setDefaultDatalake(id: string): void
+export declare function clearDefaultDatalake(): void

package/dist/node/datalake.mjs

@@ -0,0 +1,475 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { homedir } from "node:os";
+//#region ../datalake-core/dist/node/index.mjs
+var DatalakeApiError = class extends Error {
+	code;
+	requestId;
+	status;
+	constructor(status, body) {
+		super(body.message);
+		this.name = "DatalakeApiError";
+		this.code = body.code;
+		this.status = status;
+		this.requestId = body.requestId;
+	}
+};
+function datalakeCollectionPath() {
+	return `/v1/datalakes`;
+}
+function datalakeResourcePath(idOrName) {
+	return `${datalakeCollectionPath()}/${encodeURIComponent(idOrName)}`;
+}
+function datalakeGrantsPath(idOrName) {
+	return `${datalakeResourcePath(idOrName)}/grants`;
+}
+function datalakeGrantPath(idOrName, principal) {
+	return `${datalakeGrantsPath(idOrName)}/${encodeURIComponent(principal)}`;
+}
+function datalakeTokensPath(idOrName) {
+	return `${datalakeResourcePath(idOrName)}/tokens`;
+}
+var DATALAKE_HEADER_DUPLICATES = "x-datalake-duplicates";
+var DATALAKE_HEADER_REJECTED = "x-datalake-rejected";
+function datalakePlaneResourcePath(id) {
+	return `/v1/datalakes/${encodeURIComponent(id)}`;
+}
+function datalakePlaneInsertPath(id) {
+	return `${datalakePlaneResourcePath(id)}/insert`;
+}
+function datalakePlaneGetPath(id, hash) {
+	return `${datalakePlaneResourcePath(id)}/get/${encodeURIComponent(hash)}`;
+}
+function datalakePlaneGetManyPath(id) {
+	return `${datalakePlaneResourcePath(id)}/get`;
+}
+function datalakePlaneNextPath(id) {
+	return `${datalakePlaneResourcePath(id)}/next`;
+}
+function datalakePlaneDeletePath(id, hash) {
+	return `${datalakePlaneResourcePath(id)}/delete/${encodeURIComponent(hash)}`;
+}
+function datalakePlaneClearPath(id) {
+	return `${datalakePlaneResourcePath(id)}/clear`;
+}
+function datalakePlaneUsagePath(id) {
+	return `${datalakePlaneResourcePath(id)}/usage`;
+}
+//#endregion
+//#region ../datalake-client/dist/node/index.mjs
+function getAriesHome() {
+	return process.env.ARIES_HOME ?? path.join(homedir(), ".aries");
+}
+function getDatalakeStoreDir() {
+	return path.join(getAriesHome(), "datalakes");
+}
+function getLocalDatalakeStorePath() {
+	return path.join(getDatalakeStoreDir(), "local-store.json");
+}
+function getCredentialsPath() {
+	return path.join(getAriesHome(), "credentials.json");
+}
+function getDefaultDatalakePath() {
+	return path.join(getAriesHome(), "datalake-default.json");
+}
+function saveCredentials(credentials) {
+	const home = getAriesHome();
+	if (!existsSync(home)) mkdirSync(home, { recursive: true });
+	const filePath = getCredentialsPath();
+	writeFileSync(filePath, JSON.stringify(credentials, void 0, 2), "utf8");
+	try {
+		chmodSync(filePath, 384);
+	} catch {}
+}
+function loadCredentials() {
+	const filePath = getCredentialsPath();
+	if (!existsSync(filePath)) return void 0;
+	try {
+		const raw = readFileSync(filePath, "utf8");
+		return JSON.parse(raw);
+	} catch {
+		return;
+	}
+}
+function clearCredentials() {
+	const filePath = getCredentialsPath();
+	if (existsSync(filePath)) unlinkSync(filePath);
+}
+function getCredentialsLocation() {
+	return path.resolve(getCredentialsPath());
+}
+var LOCAL_OWNER_ID = "local-user";
+var TIER_SIZE_DEFAULTS = {
+	small: 10 * 1024 * 1024 * 1024,
+	medium: 100 * 1024 * 1024 * 1024,
+	large: 1024 * 1024 * 1024 * 1024,
+	archive: 10 * 1024 * 1024 * 1024 * 1024
+};
+var TIER_IOPS_DEFAULTS = {
+	small: 500,
+	medium: 2e3,
+	large: 1e4,
+	archive: 0
+};
+function readStore() {
+	const filePath = getLocalDatalakeStorePath();
+	if (!existsSync(filePath)) return { datalakes: [] };
+	try {
+		const raw = readFileSync(filePath, "utf8");
+		return JSON.parse(raw);
+	} catch {
+		return { datalakes: [] };
+	}
+}
+function writeStore(store) {
+	const dir = getDatalakeStoreDir();
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	writeFileSync(getLocalDatalakeStorePath(), JSON.stringify(store, void 0, 2), "utf8");
+}
+function generateId() {
+	return `dl_${Math.random().toString(36).slice(2, 10)}${Date.now().toString(36)}`;
+}
+function findDatalake(store, idOrName) {
+	return store.datalakes.find((dl) => dl.id === idOrName || dl.name === idOrName);
+}
+function requireDatalake(store, idOrName) {
+	const found = findDatalake(store, idOrName);
+	if (!found) throw new Error(`Datalake not found: ${idOrName}`);
+	return found;
+}
+var LocalDatalakeClient = class {
+	async create(request) {
+		const store = readStore();
+		if (store.datalakes.some((dl) => dl.name === request.name)) throw new Error(`Datalake already exists: ${request.name}`);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const tier = request.config.tier;
+		const descriptor = {
+			id: generateId(),
+			name: request.name,
+			ownerId: LOCAL_OWNER_ID,
+			config: {
+				tier,
+				sizeBytes: request.config.sizeBytes ?? TIER_SIZE_DEFAULTS[tier],
+				iops: request.config.iops ?? TIER_IOPS_DEFAULTS[tier],
+				retentionDays: request.config.retentionDays ?? 30,
+				region: request.config.region ?? "us-west-2",
+				allowedSchemas: request.config.allowedSchemas ?? [],
+				disallowedSchemas: request.config.disallowedSchemas ?? []
+			},
+			status: "ready",
+			url: `http://localhost:8080/datalakes/${request.name}`,
+			acl: [],
+			usage: {
+				payloadCount: 0,
+				bytesStored: 0,
+				bytesStoredLimit: request.config.sizeBytes ?? TIER_SIZE_DEFAULTS[tier],
+				readsLast24h: 0,
+				writesLast24h: 0
+			},
+			createdAt: now,
+			updatedAt: now
+		};
+		store.datalakes.push(descriptor);
+		writeStore(store);
+		return descriptor;
+	}
+	async describe(idOrName) {
+		return requireDatalake(readStore(), idOrName);
+	}
+	async destroy(idOrName) {
+		const store = readStore();
+		const found = findDatalake(store, idOrName);
+		if (!found) throw new Error(`Datalake not found: ${idOrName}`);
+		store.datalakes = store.datalakes.filter((dl) => dl.id !== found.id);
+		writeStore(store);
+	}
+	async grant(request) {
+		const store = readStore();
+		const datalake = requireDatalake(store, request.datalakeId);
+		const existing = datalake.acl.findIndex((entry2) => entry2.principal === request.principal);
+		const entry = {
+			principal: request.principal,
+			role: request.role,
+			grantedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			grantedBy: LOCAL_OWNER_ID
+		};
+		if (existing === -1) datalake.acl.push(entry);
+		else datalake.acl[existing] = entry;
+		datalake.updatedAt = entry.grantedAt;
+		writeStore(store);
+		return datalake;
+	}
+	async list() {
+		return readStore().datalakes;
+	}
+	async mintToken(request) {
+		const datalake = requireDatalake(readStore(), request.datalakeId);
+		const ttl = request.ttlSeconds ?? 3600;
+		return {
+			token: `local.${Buffer.from(JSON.stringify({
+				dl: datalake.id,
+				role: request.role,
+				exp: Math.floor(Date.now() / 1e3) + ttl
+			})).toString("base64url")}`,
+			datalakeId: datalake.id,
+			role: request.role,
+			expiresAt: new Date(Date.now() + ttl * 1e3).toISOString(),
+			url: datalake.url ?? `http://localhost:8080/datalakes/${datalake.name}`
+		};
+	}
+	async revoke(request) {
+		const store = readStore();
+		const datalake = requireDatalake(store, request.datalakeId);
+		datalake.acl = datalake.acl.filter((entry) => entry.principal !== request.principal);
+		datalake.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+		writeStore(store);
+		return datalake;
+	}
+};
+var RestDatalakeClient = class {
+	authToken;
+	baseUrl;
+	fetchImpl;
+	constructor(options) {
+		this.baseUrl = options.baseUrl.replace(/\/$/, "");
+		this.authToken = options.authToken;
+		this.fetchImpl = options.fetchImpl ?? fetch;
+	}
+	async create(request) {
+		const body = {
+			name: request.name,
+			config: request.config
+		};
+		return this.request(datalakeCollectionPath(), {
+			method: "POST",
+			body
+		});
+	}
+	async describe(idOrName) {
+		return this.request(datalakeResourcePath(idOrName));
+	}
+	async destroy(idOrName) {
+		await this.request(datalakeResourcePath(idOrName), { method: "DELETE" });
+	}
+	async grant(request) {
+		const body = {
+			principal: request.principal,
+			role: request.role
+		};
+		return this.request(datalakeGrantsPath(request.datalakeId), {
+			method: "POST",
+			body
+		});
+	}
+	async list() {
+		return this.request(datalakeCollectionPath());
+	}
+	async mintToken(request) {
+		const body = {
+			role: request.role,
+			ttlSeconds: request.ttlSeconds
+		};
+		return this.request(datalakeTokensPath(request.datalakeId), {
+			method: "POST",
+			body
+		});
+	}
+	async revoke(request) {
+		return this.request(datalakeGrantPath(request.datalakeId, request.principal), { method: "DELETE" });
+	}
+	async request(path4, options = {}) {
+		const url = `${this.baseUrl}${path4}`;
+		const method = options.method ?? "GET";
+		const headers = {
+			accept: "application/json",
+			authorization: `Bearer ${await this.resolveAuthToken()}`
+		};
+		const init = {
+			method,
+			headers
+		};
+		if (options.body !== void 0) {
+			headers["content-type"] = "application/json";
+			init.body = JSON.stringify(options.body);
+		}
+		const response = await this.fetchImpl(url, init);
+		if (response.status === 204) return;
+		const text = await response.text();
+		const payload = text.length > 0 ? JSON.parse(text) : void 0;
+		if (!response.ok) {
+			const errorBody = isApiErrorBody(payload) ? payload : {
+				code: "internal",
+				message: `Unexpected ${response.status} response from ${method} ${path4}`
+			};
+			throw new DatalakeApiError(response.status, errorBody);
+		}
+		return payload;
+	}
+	async resolveAuthToken() {
+		return typeof this.authToken === "function" ? await this.authToken() : this.authToken;
+	}
+};
+function isApiErrorBody(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const maybe = value;
+	return typeof maybe.code === "string" && typeof maybe.message === "string";
+}
+function createDatalakeClient(options = {}) {
+	const envBaseUrl = process.env.ARIES_DATALAKE_API;
+	const credentials = loadCredentials();
+	const baseUrl = options.baseUrl ?? envBaseUrl ?? credentials?.baseUrl;
+	const authToken = options.authToken ?? credentials?.authToken;
+	if ((options.driver ?? (baseUrl && authToken ? "rest" : "local")) === "rest") {
+		if (!baseUrl || !authToken) throw new Error("REST driver requires a baseUrl and authToken. Run `aries datalake login` or set ARIES_DATALAKE_API and sign in.");
+		return new RestDatalakeClient({
+			baseUrl,
+			authToken
+		});
+	}
+	return new LocalDatalakeClient();
+}
+function setDefaultDatalake(name, id) {
+	const home = getAriesHome();
+	if (!existsSync(home)) mkdirSync(home, { recursive: true });
+	const payload = {
+		name,
+		id,
+		setAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	writeFileSync(getDefaultDatalakePath(), JSON.stringify(payload, void 0, 2), "utf8");
+}
+function getDefaultDatalake() {
+	const filePath = getDefaultDatalakePath();
+	if (!existsSync(filePath)) return void 0;
+	try {
+		const raw = readFileSync(filePath, "utf8");
+		return JSON.parse(raw).name;
+	} catch {
+		return;
+	}
+}
+function clearDefaultDatalake() {
+	const filePath = getDefaultDatalakePath();
+	if (existsSync(filePath)) unlinkSync(filePath);
+}
+function extractOrigin(urlWithPossiblePath) {
+	try {
+		const parsed = new URL(urlWithPossiblePath);
+		return `${parsed.protocol}//${parsed.host}`;
+	} catch {
+		return urlWithPossiblePath.replace(/\/$/, "");
+	}
+}
+var RestPayloadsClient = class {
+	authToken;
+	datalakeId;
+	fetchImpl;
+	origin;
+	constructor(options) {
+		this.origin = extractOrigin(options.baseUrl);
+		this.datalakeId = options.datalakeId;
+		this.authToken = options.authToken;
+		this.fetchImpl = options.fetchImpl ?? fetch;
+	}
+	async clear() {
+		return this.request(datalakePlaneClearPath(this.datalakeId), { method: "POST" });
+	}
+	async delete(hash) {
+		await this.request(datalakePlaneDeletePath(this.datalakeId, hash), { method: "DELETE" });
+	}
+	async get(hash) {
+		return this.request(datalakePlaneGetPath(this.datalakeId, hash));
+	}
+	async getMany(hashes) {
+		if (hashes.length === 0) return [];
+		return this.request(datalakePlaneGetManyPath(this.datalakeId), {
+			method: "POST",
+			body: hashes
+		});
+	}
+	async insert(payloads) {
+		const body = payloads;
+		const { data, headers } = await this.requestWithHeaders(datalakePlaneInsertPath(this.datalakeId), {
+			method: "POST",
+			body
+		});
+		return {
+			inserted: data,
+			summary: readInsertSummary(headers)
+		};
+	}
+	async next(options = {}) {
+		const params = new URLSearchParams();
+		if (options.limit !== void 0) params.set("limit", String(options.limit));
+		if (options.cursor) params.set("cursor", options.cursor);
+		if (options.schemas && options.schemas.length > 0) params.set("schemas", options.schemas.join(","));
+		if (options.order) params.set("order", options.order);
+		const suffix = params.toString();
+		const path4 = suffix ? `${datalakePlaneNextPath(this.datalakeId)}?${suffix}` : datalakePlaneNextPath(this.datalakeId);
+		const { data, headers } = await this.requestWithHeaders(path4);
+		return {
+			payloads: data,
+			nextCursor: headers.get("x-datalake-next-cursor") ?? void 0
+		};
+	}
+	async usage() {
+		return this.request(datalakePlaneUsagePath(this.datalakeId));
+	}
+	async request(path4, options = {}) {
+		const { data } = await this.requestWithHeaders(path4, options);
+		return data;
+	}
+	async requestWithHeaders(path4, options = {}) {
+		const method = options.method ?? "GET";
+		const headers = {
+			accept: "application/json",
+			authorization: `Bearer ${await this.resolveAuthToken()}`
+		};
+		const init = {
+			method,
+			headers
+		};
+		if (options.body !== void 0) {
+			headers["content-type"] = "application/json";
+			init.body = JSON.stringify(options.body);
+		}
+		const response = await this.fetchImpl(`${this.origin}${path4}`, init);
+		if (response.status === 204) return {
+			data: void 0,
+			headers: response.headers
+		};
+		const text = await response.text();
+		const payload = text.length > 0 ? JSON.parse(text) : void 0;
+		if (!response.ok) {
+			const errorBody = isApiErrorBody2(payload) ? payload : {
+				code: "internal",
+				message: `Unexpected ${response.status} response from ${method} ${path4}`
+			};
+			throw new DatalakeApiError(response.status, errorBody);
+		}
+		return {
+			data: payload,
+			headers: response.headers
+		};
+	}
+	async resolveAuthToken() {
+		return typeof this.authToken === "function" ? await this.authToken() : this.authToken;
+	}
+};
+function readInsertSummary(headers) {
+	const duplicatesRaw = headers.get(DATALAKE_HEADER_DUPLICATES);
+	const duplicates = duplicatesRaw === null ? 0 : Number.parseInt(duplicatesRaw, 10);
+	const rejectedRaw = headers.get(DATALAKE_HEADER_REJECTED);
+	const rejected = rejectedRaw === null || rejectedRaw.length === 0 ? [] : rejectedRaw.split(",").map((value) => value.trim()).filter((value) => value.length > 0);
+	return {
+		duplicates: Number.isFinite(duplicates) ? duplicates : 0,
+		rejected
+	};
+}
+function isApiErrorBody2(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const maybe = value;
+	return typeof maybe.code === "string" && typeof maybe.message === "string";
+}
+//#endregion
+export { LocalDatalakeClient, RestDatalakeClient, RestPayloadsClient, clearCredentials, clearDefaultDatalake, createDatalakeClient, getCredentialsLocation, getDefaultDatalake, loadCredentials, saveCredentials, setDefaultDatalake };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ariestools/cli",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Aries Tools CLI - A suite of tools by Arie Trouw",
   "keywords": [
     "ariestools",
@@ -16,17 +16,25 @@
   },
   "sideEffects": false,
   "type": "module",
+  "exports": {
+    "./datalake": {
+      "types": "./dist/node/datalake.d.ts",
+      "default": "./dist/node/datalake.mjs"
+    },
+    "./package.json": "./package.json"
+  },
   "bin": {
     "aries": "dist/bin/aries.mjs"
   },
   "files": [
     "dist/bin",
+    "dist/node",
     "dist/plugins",
     "README.md"
   ],
   "dependencies": {
     "@opentelemetry/api": "~1.9.1",
-    "@xyo-network/sdk-protocol": "~7.2.1",
+    "@xyo-network/sdk-protocol": "~7.2.2",
     "async-mutex": "~0.5.0",
     "ethers": "~6.17.0",
     "imghash": "~1.1.4",
@@ -35,15 +43,14 @@
     "sharp": "~0.35.3",
     "sharp-phash": "~2.2.0",
     "zod": "~4.4.3",
-    "@ariestools/aries-chain-serve": "~0.1.8",
-    "@xyo-network/wallet-xl1-cli": "~0.1.8",
-    "@ariestools/aries-dapp-serve": "~0.1.8",
-    "@ariestools/aries-dapp-core": "~0.1.8"
+    "@ariestools/aries-dapp-core": "~0.1.9",
+    "@xyo-network/wallet-xl1-cli": "~0.1.9",
+    "@ariestools/aries-dapp-serve": "~0.1.9"
   },
   "devDependencies": {
-    "@ariestools/sdk": "~8.1.1",
-    "@ariestools/toolchain": "~8.7.18",
-    "@ariestools/tsconfig": "~8.7.18",
+    "@ariestools/sdk": "~8.1.2",
+    "@ariestools/toolchain": "~8.7.20",
+    "@ariestools/tsconfig": "~8.7.20",
     "@metamask/json-rpc-engine": "~10.5.0",
     "@types/node": "~26.1.1",
     "@xyo-network/sdk": "~7.2.1",
@@ -54,7 +61,8 @@
     "typescript": "~6.0.3",
     "vite": "~8.1.5",
     "vitest": "~4.1.10",
-    "@ariestools/cli-lib": "~0.1.8"
+    "@ariestools/cli-lib": "~0.1.9",
+    "@ariestools/aries-datalake-client": "~0.1.9"
   },
   "engines": {
     "node": ">=18.17.1"
@@ -65,6 +73,6 @@
   },
   "scripts": {
     "package-clean": "rm -rf dist bundle",
-    "package-compile": "tsc -p tsconfig.build.json --noEmit && rolldown -c rolldown.config.ts && tsx scripts/buildBundle.ts"
+    "package-compile": "tsc -p tsconfig.build.json --noEmit && rolldown -c rolldown.config.ts && tsx scripts/buildBundle.ts && tsx scripts/emitDatalakeTypes.ts"
   }
 }