@lumeweb/pinner 0.1.0 → 0.1.1

package/dist/cjs/adapters/pinata/v2/adapter.cjs

@@ -0,0 +1,636 @@
+const require_constants = require('../../../types/constants.cjs');
+const require_utils = require('../shared/utils.cjs');
+
+//#region src/adapters/pinata/v2/adapter.ts
+/**
+* Implementation of UploadBuilder
+*/
+var UploadBuilderImpl = class {
+	_name;
+	_keyvalues;
+	constructor(pinner, executeFn) {
+		this.pinner = pinner;
+		this.executeFn = executeFn;
+	}
+	name(name) {
+		this._name = name;
+		return this;
+	}
+	keyvalues(keyvalues) {
+		this._keyvalues = keyvalues;
+		return this;
+	}
+	async execute() {
+		return this.executeFn(this._name, this._keyvalues);
+	}
+};
+/**
+* Implementation of FilterFiles
+*/
+var FilterFilesImpl = class {
+	query = {};
+	currentPageToken;
+	privacy;
+	constructor(pinner, privacy) {
+		this.pinner = pinner;
+		this.privacy = privacy;
+	}
+	name(name) {
+		this.query.name = name;
+		return this;
+	}
+	group(group) {
+		this.query.group = group;
+		return this;
+	}
+	cid(cid) {
+		this.query.cid = cid;
+		return this;
+	}
+	mimeType(mimeType) {
+		this.query.mimeType = mimeType;
+		return this;
+	}
+	order(order) {
+		this.query.order = order;
+		return this;
+	}
+	limit(limit) {
+		this.query.limit = limit;
+		return this;
+	}
+	cidPending(cidPending) {
+		this.query.cidPending = cidPending;
+		return this;
+	}
+	keyvalues(keyvalues) {
+		this.query.metadata = keyvalues;
+		return this;
+	}
+	noGroup(noGroup) {
+		this.query.noGroup = noGroup;
+		return this;
+	}
+	pageToken(pageToken) {
+		this.query.pageToken = Number.parseInt(pageToken, 10);
+		return this;
+	}
+	then(onfulfilled, onrejected) {
+		return this.fetchPage().then(onfulfilled, onrejected);
+	}
+	async fetchPage() {
+		return {
+			files: (await this.pinner.listPins({ limit: this.query.limit })).map((pin) => ({
+				id: pin.cid.toString(),
+				name: pin.name || null,
+				cid: pin.cid.toString(),
+				size: pin.size || 0,
+				number_of_files: 1,
+				mime_type: "application/octet-stream",
+				keyvalues: pin.metadata || {},
+				group_id: null,
+				created_at: pin.created.toISOString()
+			})),
+			next_page_token: this.currentPageToken || ""
+		};
+	}
+	async *[Symbol.asyncIterator]() {
+		while (true) {
+			const items = await this.fetchPage();
+			for (const item of items.files) yield item;
+			if (!this.currentPageToken) break;
+		}
+	}
+	async all() {
+		const allItems = [];
+		for await (const item of this) allItems.push(item);
+		return allItems;
+	}
+};
+/**
+* Implementation of FilterQueue
+*/
+var FilterQueueImpl = class {
+	query = {};
+	currentPageToken;
+	constructor(pinner) {
+		this.pinner = pinner;
+	}
+	cid(cid) {
+		this.query.cid = cid;
+		return this;
+	}
+	status(status) {
+		this.query.status = status;
+		return this;
+	}
+	pageLimit(limit) {
+		this.query.limit = limit;
+		return this;
+	}
+	pageToken(pageToken) {
+		this.query.pageToken = pageToken;
+		return this;
+	}
+	sort(sort) {
+		this.query.sort = sort;
+		return this;
+	}
+	then(onfulfilled, onrejected) {
+		return this.fetchPage().then(onfulfilled, onrejected);
+	}
+	async fetchPage() {
+		return {
+			jobs: (await this.pinner.listPins({ limit: this.query.limit })).map((pin) => ({
+				id: pin.cid.toString(),
+				cid: pin.cid.toString(),
+				date_queued: pin.created.toISOString(),
+				name: pin.name || "",
+				status: pin.status || "pinned",
+				keyvalues: pin.metadata || {},
+				host_nodes: [],
+				pin_policy: {
+					regions: [],
+					version: 1
+				}
+			})),
+			next_page_token: this.currentPageToken || ""
+		};
+	}
+	async *[Symbol.asyncIterator]() {
+		while (true) {
+			const items = await this.fetchPage();
+			for (const item of items.jobs) yield item;
+			if (!this.currentPageToken) break;
+		}
+	}
+	async all() {
+		const allItems = [];
+		for await (const item of this) allItems.push(item);
+		return allItems;
+	}
+};
+/**
+* Implementation of FilterGroups
+*/
+var FilterGroupsImpl = class {
+	currentPageToken;
+	privacy;
+	constructor(pinner, privacy) {
+		this.pinner = pinner;
+		this.privacy = privacy;
+	}
+	name(name) {
+		return this;
+	}
+	limit(limit) {
+		return this;
+	}
+	pageToken(pageToken) {
+		this.currentPageToken = pageToken;
+		return this;
+	}
+	isPublic(isPublic) {
+		return this;
+	}
+	then(onfulfilled, onrejected) {
+		return this.fetchPage().then(onfulfilled, onrejected);
+	}
+	async fetchPage() {
+		return {
+			groups: [],
+			next_page_token: this.currentPageToken || ""
+		};
+	}
+	async *[Symbol.asyncIterator]() {
+		const items = await this.fetchPage();
+		for (const item of items.groups) yield item;
+	}
+	async all() {
+		const allItems = [];
+		for await (const item of this) allItems.push(item);
+		return allItems;
+	}
+};
+/**
+* Implementation of PublicUpload
+*/
+var PublicUploadImpl = class {
+	constructor(pinner, config) {
+		this.pinner = pinner;
+		this.config = config;
+	}
+	file(file, options) {
+		return new UploadBuilderImpl(this.pinner, async (name, keyvalues) => {
+			const result = await this.pinner.uploadAndWait(file, {
+				name: name || options?.metadata?.name,
+				keyvalues: keyvalues || options?.metadata?.keyvalues
+			});
+			return {
+				id: result.cid,
+				name: file.name,
+				cid: result.cid,
+				size: result.size,
+				created_at: result.createdAt.toISOString(),
+				number_of_files: 1,
+				mime_type: file.type || "application/octet-stream",
+				group_id: null,
+				keyvalues: keyvalues || options?.metadata?.keyvalues || {},
+				vectorized: false,
+				network: "public"
+			};
+		});
+	}
+	fileArray(files, options) {
+		return new UploadBuilderImpl(this.pinner, async (name, keyvalues) => {
+			const result = await (await this.pinner.uploadDirectory(files, {
+				name: name || options?.metadata?.name,
+				keyvalues: keyvalues || options?.metadata?.keyvalues
+			})).result;
+			return {
+				id: result.cid,
+				name: name || options?.metadata?.name || "directory",
+				cid: result.cid,
+				size: result.size,
+				created_at: result.createdAt.toISOString(),
+				number_of_files: files.length,
+				mime_type: "application/octet-stream",
+				group_id: null,
+				keyvalues: keyvalues || options?.metadata?.keyvalues || {},
+				vectorized: false,
+				network: "public"
+			};
+		});
+	}
+	base64(base64String, options) {
+		return new UploadBuilderImpl(this.pinner, async (name, keyvalues) => {
+			const binaryString = atob(base64String);
+			const bytes = new Uint8Array(binaryString.length);
+			for (let i = 0; i < binaryString.length; i++) bytes[i] = binaryString.charCodeAt(i);
+			const blob = new Blob([bytes], { type: "application/octet-stream" });
+			const file = new File([blob], name || options?.metadata?.name || "file.bin", { type: "application/octet-stream" });
+			const result = await this.pinner.uploadAndWait(file, {
+				name: name || options?.metadata?.name,
+				keyvalues: keyvalues || options?.metadata?.keyvalues
+			});
+			return {
+				id: result.cid,
+				name: file.name,
+				cid: result.cid,
+				size: result.size,
+				created_at: result.createdAt.toISOString(),
+				number_of_files: 1,
+				mime_type: "application/octet-stream",
+				group_id: null,
+				keyvalues: keyvalues || options?.metadata?.keyvalues || {},
+				vectorized: false,
+				network: "public"
+			};
+		});
+	}
+	url(url, options) {
+		return new UploadBuilderImpl(this.pinner, async () => {
+			require_utils.notSupported("URL upload");
+		});
+	}
+	json(data, options) {
+		return new UploadBuilderImpl(this.pinner, async (name, keyvalues) => {
+			const jsonString = JSON.stringify(data);
+			const file = new File([jsonString], name || options?.metadata?.name || "data.json", { type: "application/json" });
+			const result = await this.pinner.uploadAndWait(file, {
+				name: name || options?.metadata?.name,
+				keyvalues: keyvalues || options?.metadata?.keyvalues
+			});
+			return {
+				id: result.cid,
+				name: file.name,
+				cid: result.cid,
+				size: result.size,
+				created_at: result.createdAt.toISOString(),
+				number_of_files: 1,
+				mime_type: "application/json",
+				group_id: null,
+				keyvalues: keyvalues || options?.metadata?.keyvalues || {},
+				vectorized: false,
+				network: "public"
+			};
+		});
+	}
+	cid(cid, options) {
+		return new UploadBuilderImpl(this.pinner, async () => {
+			const cidObj = require_utils.parseCID(cid);
+			const generator = await this.pinner.pinByHash(cidObj, {
+				name: options?.metadata?.name,
+				metadata: options?.metadata?.keyvalues
+			});
+			for await (const _ of generator);
+			return {
+				id: cid,
+				cid,
+				date_queued: (/* @__PURE__ */ new Date()).toISOString(),
+				name: options?.metadata?.name || "",
+				status: "pinned",
+				keyvalues: options?.metadata?.keyvalues || null,
+				host_nodes: null,
+				group_id: options?.groupId || null
+			};
+		});
+	}
+	async createSignedURL(options) {
+		require_utils.notSupported("Signed upload URLs");
+	}
+};
+/**
+* Implementation of PrivateUpload
+*/
+var PrivateUploadImpl = class {
+	constructor(pinner, config) {
+		this.pinner = pinner;
+		this.config = config;
+	}
+	file(file, options) {
+		return new UploadBuilderImpl(this.pinner, async () => {
+			require_utils.notSupported("Private upload");
+		});
+	}
+	fileArray(files, options) {
+		return new UploadBuilderImpl(this.pinner, async () => {
+			require_utils.notSupported("Private upload");
+		});
+	}
+	base64(base64String, options) {
+		return new UploadBuilderImpl(this.pinner, async () => {
+			require_utils.notSupported("Private upload");
+		});
+	}
+	url(url, options) {
+		return new UploadBuilderImpl(this.pinner, async () => {
+			require_utils.notSupported("Private upload");
+		});
+	}
+	json(data, options) {
+		return new UploadBuilderImpl(this.pinner, async () => {
+			require_utils.notSupported("Private upload");
+		});
+	}
+	cid(cid, options) {
+		return new UploadBuilderImpl(this.pinner, async () => {
+			require_utils.notSupported("Private upload");
+		});
+	}
+	async createSignedURL(options) {
+		require_utils.notSupported("Private upload");
+	}
+};
+/**
+* Implementation of PublicFiles
+*/
+var PublicFilesImpl = class {
+	constructor(pinner, config) {
+		this.pinner = pinner;
+		this.config = config;
+	}
+	list() {
+		return new FilterFilesImpl(this.pinner, "public");
+	}
+	async get(id) {
+		const cidObj = require_utils.parseCID(id);
+		const pin = await this.pinner.getPinStatus(cidObj);
+		return {
+			id: pin.cid.toString(),
+			name: pin.name || null,
+			cid: pin.cid.toString(),
+			size: pin.size || 0,
+			number_of_files: 1,
+			mime_type: "application/octet-stream",
+			keyvalues: pin.metadata || {},
+			group_id: null,
+			created_at: pin.created.toISOString()
+		};
+	}
+	async delete(files) {
+		const results = [];
+		for (const file of files) {
+			await this.pinner.unpin(file);
+			results.push({
+				id: file,
+				status: "deleted"
+			});
+		}
+		return results;
+	}
+	async update(options) {
+		await this.pinner.setPinMetadata(options.id, options.keyvalues || {});
+		const pin = await this.pinner.getPinStatus(require_utils.parseCID(options.id));
+		return {
+			id: pin.cid.toString(),
+			name: pin.name || null,
+			cid: pin.cid.toString(),
+			size: pin.size || 0,
+			number_of_files: 1,
+			mime_type: "application/octet-stream",
+			keyvalues: pin.metadata || {},
+			group_id: null,
+			created_at: pin.created.toISOString()
+		};
+	}
+	async addSwap(options) {
+		require_utils.notSupported("Swap CID");
+	}
+	async getSwapHistory(options) {
+		return [];
+	}
+	async deleteSwap(cid) {
+		require_utils.notSupported("Swap CID");
+	}
+	queue() {
+		return new FilterQueueImpl(this.pinner);
+	}
+	async deletePinRequest(requestId) {
+		await this.pinner.unpinByRequestId(requestId);
+		return requestId;
+	}
+};
+/**
+* Implementation of PrivateFiles
+*/
+var PrivateFilesImpl = class {
+	constructor(pinner, config) {
+		this.pinner = pinner;
+		this.config = config;
+	}
+	list() {
+		require_utils.notSupported("Private files");
+	}
+	async get(id) {
+		require_utils.notSupported("Private files");
+	}
+	async delete(files) {
+		require_utils.notSupported("Private files");
+	}
+	async update(options) {
+		require_utils.notSupported("Private files");
+	}
+	async addSwap(options) {
+		require_utils.notSupported("Private files");
+	}
+	async getSwapHistory(options) {
+		require_utils.notSupported("Private files");
+	}
+	async deleteSwap(cid) {
+		require_utils.notSupported("Private files");
+	}
+	queue() {
+		require_utils.notSupported("Private files");
+	}
+	async deletePinRequest(requestId) {
+		require_utils.notSupported("Private files");
+	}
+};
+/**
+* Implementation of PublicGateways
+*/
+var PublicGatewaysImpl = class {
+	constructor(pinner, config) {
+		this.pinner = pinner;
+		this.config = config;
+	}
+	get(cid) {
+		return {
+			cid,
+			gateway: this.config?.pinataGateway || require_constants.DEFAULT_GATEWAY,
+			url: `${this.config?.pinataGateway || require_constants.DEFAULT_GATEWAY}/ipfs/${cid}`
+		};
+	}
+	async convert(url, gatewayPrefix) {
+		const gateway = gatewayPrefix || this.config?.pinataGateway || require_constants.DEFAULT_GATEWAY;
+		return url.replace("ipfs://", `${gateway}/ipfs/`);
+	}
+};
+/**
+* Implementation of PrivateGateways
+*/
+var PrivateGatewaysImpl = class {
+	constructor(pinner, config) {
+		this.pinner = pinner;
+		this.config = config;
+	}
+	get(cid) {
+		require_utils.notSupported("Private gateways");
+	}
+	createAccessLink(options) {
+		require_utils.notSupported("Private gateways");
+	}
+};
+/**
+* Implementation of PublicGroups
+*/
+var PublicGroupsImpl = class {
+	constructor(pinner, config) {
+		this.pinner = pinner;
+		this.config = config;
+	}
+	async create(options) {
+		require_utils.notSupported("Groups");
+	}
+	list() {
+		return new FilterGroupsImpl(this.pinner, "public");
+	}
+	async get(options) {
+		require_utils.notSupported("Groups");
+	}
+	async addFiles(options) {
+		require_utils.notSupported("Groups");
+	}
+	async removeFiles(options) {
+		require_utils.notSupported("Groups");
+	}
+	async update(options) {
+		require_utils.notSupported("Groups");
+	}
+	async delete(options) {
+		require_utils.notSupported("Groups");
+	}
+};
+/**
+* Implementation of PrivateGroups
+*/
+var PrivateGroupsImpl = class {
+	constructor(pinner, config) {
+		this.pinner = pinner;
+		this.config = config;
+	}
+	async create(options) {
+		require_utils.notSupported("Private groups");
+	}
+	list() {
+		require_utils.notSupported("Private groups");
+	}
+	async get(options) {
+		require_utils.notSupported("Private groups");
+	}
+	async addFiles(options) {
+		require_utils.notSupported("Private groups");
+	}
+	async removeFiles(options) {
+		require_utils.notSupported("Private groups");
+	}
+	async update(options) {
+		require_utils.notSupported("Private groups");
+	}
+	async delete(options) {
+		require_utils.notSupported("Private groups");
+	}
+};
+/**
+* Implementation of Analytics
+*/
+var AnalyticsImpl = class {
+	async requests(query) {
+		return { data: [] };
+	}
+	async bandwidth(query) {
+		return {
+			total_requests: 0,
+			total_bandwidth: 0,
+			time_periods: []
+		};
+	}
+};
+/**
+* Create Pinata Adapter
+*
+* @param pinner - Pinner client instance
+* @param config - Pinata configuration
+* @returns PinataAdapter
+*/
+function pinataAdapter(pinner, config) {
+	const effectiveConfig = config || {};
+	return {
+		config: effectiveConfig,
+		updateConfig(newConfig) {
+			Object.assign(effectiveConfig, newConfig);
+		},
+		upload: {
+			public: new PublicUploadImpl(pinner, effectiveConfig),
+			private: new PrivateUploadImpl(pinner, effectiveConfig)
+		},
+		files: {
+			public: new PublicFilesImpl(pinner, effectiveConfig),
+			private: new PrivateFilesImpl(pinner, effectiveConfig)
+		},
+		gateways: {
+			public: new PublicGatewaysImpl(pinner, effectiveConfig),
+			private: new PrivateGatewaysImpl(pinner, effectiveConfig)
+		},
+		groups: {
+			public: new PublicGroupsImpl(pinner, effectiveConfig),
+			private: new PrivateGroupsImpl(pinner, effectiveConfig)
+		},
+		analytics: new AnalyticsImpl()
+	};
+}
+
+//#endregion
+exports.pinataAdapter = pinataAdapter;
+//# sourceMappingURL=adapter.cjs.map