@wener/common 2.0.2 → 2.0.5

package/src/fs/minio/index.ts

@@ -0,0 +1 @@
+export { createMinioFileSystem, type CreateMinioFileSystemOptions } from './createMinioFileSystem';

package/src/fs/orpc/FileSystemContract.ts

@@ -0,0 +1,92 @@
+import { oc } from '@orpc/contract';
+import { z } from 'zod/v4';
+import { FileKindSchema } from '../types';
+
+export type FileStat = z.infer<typeof FileStatSchema>;
+export const FileStatSchema = z.object({
+	directory: z.string(),
+	path: z.string(),
+	name: z.string(),
+	kind: FileKindSchema,
+	mtime: z.coerce.date(),
+	size: z.coerce.number().nonnegative().default(0),
+	meta: z.record(z.string(), z.any()),
+});
+export type ReaddirInput = z.infer<typeof ReaddirInputSchema>;
+export const ReaddirInputSchema = z.object({
+	dir: z.string().nonempty(),
+	glob: z.string().optional(),
+	recursive: z.boolean().default(false),
+	depth: z.number().min(0).optional(),
+	kind: FileKindSchema.optional(),
+	cursor: z.string().optional(),
+	hidden: z.boolean().default(false),
+});
+const ReaddirOutputSchema = z.object({
+	data: FileStatSchema.array(),
+});
+const StatInputSchema = z.object({
+	path: z.string(),
+});
+const StatOutputSchema = z.object({
+	data: FileStatSchema,
+});
+const CreateDirectoryInputSchema = z.object({
+	path: z.string(),
+	recursive: z.boolean().nullish(),
+});
+const CreateDirectoryOutputSchema = z.object({}).default({});
+const RenameInputSchema = z.object({
+	oldPath: z.string(),
+	newPath: z.string(),
+	overwrite: z.boolean().nullish(),
+});
+const RenameOutputSchema = z.object({}).default({});
+const ExistsInputSchema = z.object({
+	path: z.string(),
+});
+const ExistsOutputSchema = z.object({
+	data: z.boolean(),
+});
+const CopyInputSchema = z.object({
+	src: z.string(),
+	dest: z.string(),
+	overwrite: z.boolean().nullish(),
+	shallow: z.boolean().nullish(),
+});
+const CopyOutputSchema = z.object({}).default({});
+const ReadFileInputSchema = z.object({
+	path: z.string(),
+});
+const ReadFileOutputSchema = z.object({
+	base64: z.string(),
+});
+const WriteFileInputSchema = z.object({
+	path: z.string(),
+	base64: z.string(),
+	overwrite: z.boolean().optional(),
+});
+const WriteFileOutputSchema = z.object({});
+const RemoveInputSchema = z.object({
+	path: z.string(),
+	recursive: z.boolean().nullish(),
+	force: z.boolean().nullish(),
+});
+const RemoveOutputSchema = z.object({}).default({});
+export const FileSystemContract = {
+	readdir: oc.input(ReaddirInputSchema).output(ReaddirOutputSchema).route({ description: 'List directory contents' }),
+	stat: oc.input(StatInputSchema).output(StatOutputSchema).route({
+		method: 'GET',
+		description: 'Get file or directory status',
+	}),
+	mkdir: oc
+		.input(CreateDirectoryInputSchema)
+		.output(CreateDirectoryOutputSchema)
+		.route({ description: 'Create a directory' }),
+	readFile: oc.input(ReadFileInputSchema).output(ReadFileOutputSchema).route({ description: 'Read file' }),
+	writeFile: oc.input(WriteFileInputSchema).output(WriteFileOutputSchema),
+	rename: oc.input(RenameInputSchema).output(RenameOutputSchema),
+	exists: oc.input(ExistsInputSchema).output(ExistsOutputSchema),
+	copy: oc.input(CopyInputSchema).output(CopyOutputSchema),
+	rm: oc.input(RemoveInputSchema).output(RemoveOutputSchema),
+};

package/src/fs/orpc/createContractClientFileSystem.ts

@@ -0,0 +1,115 @@
+import type { Readable, Writable } from 'node:stream';
+import type { ContractRouterClient } from '@orpc/contract';
+import { ArrayBuffers } from '@wener/utils';
+import type {
+	CopyOptions,
+	CreateReadStreamOptions,
+	CreateWriteStreamOptions,
+	IFileSystem,
+	MkdirOptions,
+	ReaddirOptions,
+	ReadFileOptions,
+	RenameOptions,
+	RmOptions,
+	StatOptions,
+	WritableData,
+	WriteFileOptions,
+} from '../IFileSystem';
+import { resolveData } from '../utils';
+import type { FileSystemContract } from './FileSystemContract';
+
+type FileSystemContractClient = ContractRouterClient<typeof FileSystemContract>;
+
+export function createContractClientFileSystem(client: FileSystemContractClient): IFileSystem & {
+	client: FileSystemContractClient;
+} {
+	return new ContractFS(client);
+}
+
+class ContractFS implements IFileSystem {
+	client: FileSystemContractClient;
+
+	constructor(client: FileSystemContractClient) {
+		this.client = client;
+	}
+
+	async readdir(dir: string, options: ReaddirOptions = {}) {
+		const { data } = await this.client.readdir({ dir, ...options });
+		return data.map((stat) => ({
+			...stat,
+			mtime: stat.mtime.getTime(),
+		}));
+	}
+
+	async stat(entry: string, _options?: StatOptions) {
+		const { data } = await this.client.stat({ path: entry });
+		return {
+			...data,
+			mtime: data.mtime.getTime(),
+		};
+	}
+
+	async mkdir(path: string, options?: MkdirOptions) {
+		await this.client.mkdir({
+			path,
+			recursive: options?.recursive,
+		});
+	}
+
+	readFile(path: string, options?: ReadFileOptions & { encoding: 'text' }): Promise<string>;
+	readFile(path: string, options?: ReadFileOptions): Promise<Uint8Array>;
+	async readFile(path: string, options?: ReadFileOptions): Promise<string | Uint8Array> {
+		// Note: The contract doesn't currently support encoding options.
+		const { base64 } = await this.client.readFile({ path });
+		let enc = options?.encoding || 'binary';
+		let buf = ArrayBuffers.fromBase64(base64);
+		switch (enc) {
+			case 'text':
+				return ArrayBuffers.toString(buf);
+		}
+		return buf;
+	}
+
+	async writeFile(path: string, data: WritableData, options?: WriteFileOptions) {
+		let buf = resolveData(data);
+		await this.client.writeFile({ path, base64: ArrayBuffers.toBase64(buf as BufferSource), ...options });
+	}
+
+	async rename(oldPath: string, newPath: string, options?: RenameOptions) {
+		await this.client.rename({
+			oldPath,
+			newPath,
+			overwrite: options?.overwrite,
+		});
+	}
+
+	async exists(path: string) {
+		const { data } = await this.client.exists({ path });
+		return data;
+	}
+
+	async copy(src: string, dest: string, options?: CopyOptions) {
+		await this.client.copy({
+			src,
+			dest,
+			overwrite: options?.overwrite,
+			shallow: options?.shallow,
+		});
+	}
+
+	async rm(path: string, options?: RmOptions) {
+		await this.client.rm({
+			path,
+			recursive: options?.recursive,
+			force: options?.force,
+		});
+	}
+
+	createReadStream(_path: string, _options?: CreateReadStreamOptions): Readable {
+		throw new Error('createReadStream is not implemented in ContractFS');
+	}
+
+	createWriteStream(_path: string, _options?: CreateWriteStreamOptions): Writable {
+		throw new Error('createWriteStream is not implemented in ContractFS');
+	}
+}

package/src/fs/orpc/index.ts

@@ -0,0 +1,2 @@
+export { createContractClientFileSystem } from './createContractClientFileSystem';
+export { FileSystemContract } from './FileSystemContract';

package/src/fs/orpc/server/createFileSystemContractImpl.ts

@@ -0,0 +1,64 @@
+import { implement } from '@orpc/server';
+import { ArrayBuffers } from '@wener/utils';
+import type { IFileSystem } from '../../IFileSystem';
+import { FileSystemContract } from '../FileSystemContract';
+
+export function createFileSystemContractImpl(ifs: IFileSystem) {
+	const os = implement(FileSystemContract);
+
+	return {
+		readdir: os.readdir.handler(async ({ input }) => {
+			return {
+				data: await ifs.readdir(input.dir),
+			};
+		}),
+		stat: os.stat.handler(async ({ input }) => {
+			return {
+				data: await ifs.stat(input.path),
+			};
+		}),
+		mkdir: os.mkdir.handler(async ({ input }) => {
+			await ifs.mkdir(input.path, {
+				recursive: input.recursive ?? false,
+			});
+			return {};
+		}),
+		rename: os.rename.handler(async ({ input }) => {
+			await ifs.rename(input.oldPath, input.newPath, {
+				overwrite: input.overwrite ?? false,
+			});
+			return {};
+		}),
+		exists: os.exists.handler(async ({ input }) => {
+			return {
+				data: await ifs.exists(input.path),
+			};
+		}),
+		copy: os.copy.handler(async ({ input }) => {
+			await ifs.copy(input.src, input.dest, {
+				overwrite: input.overwrite ?? false,
+				shallow: input.shallow ?? false,
+			});
+			return {};
+		}),
+		readFile: os.readFile.handler(async ({ input }) => {
+			return {
+				base64: ArrayBuffers.toBase64((await ifs.readFile(input.path, { encoding: 'binary' })) as BufferSource),
+			};
+		}),
+		writeFile: os.writeFile.handler(async ({ input }) => {
+			await ifs.writeFile(input.path, Buffer.from(input.base64, 'base64'), {
+				overwrite: input.overwrite,
+			});
+			return {};
+		}),
+
+		rm: os.rm.handler(async ({ input }) => {
+			await ifs.rm(input.path, {
+				recursive: input.recursive ?? undefined,
+				force: input.force ?? undefined,
+			});
+			return {};
+		}),
+	};
+}

package/src/fs/orpc/server/index.ts

@@ -0,0 +1 @@
+export { createFileSystemContractImpl } from './createFileSystemContractImpl';