sizuku 0.0.7 → 0.2.0

package/dist/shared/utils/compose.js

@@ -0,0 +1,124 @@
+/**
+ * Functional composition utilities for cleaner code
+ *
+ * @module compose
+ */
+/**
+ * Pipes a value through a series of functions from left to right
+ *
+ * @template T - Initial value type
+ * @param value - The initial value
+ * @param fns - Functions to apply in sequence
+ * @returns The final transformed value
+ *
+ * @example
+ * const result = pipe(
+ *   "hello",
+ *   str => str.toUpperCase(),
+ *   str => str + "!",
+ *   str => str.repeat(2)
+ * ) // "HELLO!HELLO!"
+ */
+export function pipe(value, ...fns) {
+    return fns.reduce((acc, fn) => fn(acc), value);
+}
+/**
+ * Composes functions from right to left
+ *
+ * @param fns - Functions to compose
+ * @returns A new function that applies all functions in sequence
+ *
+ * @example
+ * const transform = compose(
+ *   str => str.repeat(2),
+ *   str => str + "!",
+ *   str => str.toUpperCase()
+ * )
+ * transform("hello") // "HELLO!HELLO!"
+ */
+export function compose(...fns) {
+    return (arg) => fns.reduceRight((acc, fn) => fn(acc), arg);
+}
+/**
+ * Maybe monad for handling nullable values
+ *
+ * @template T - The wrapped value type
+ */
+export class Maybe {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    /**
+     * Creates a Maybe from a value
+     */
+    static of(value) {
+        return new Maybe(value);
+    }
+    /**
+     * Creates a Maybe with no value
+     */
+    static none() {
+        return new Maybe(null);
+    }
+    /**
+     * Maps a function over the Maybe value
+     */
+    map(fn) {
+        return this.value == null ? Maybe.none() : Maybe.of(fn(this.value));
+    }
+    /**
+     * Flat maps a function that returns a Maybe
+     */
+    flatMap(fn) {
+        return this.value == null ? Maybe.none() : fn(this.value);
+    }
+    /**
+     * Returns the value or a default
+     */
+    getOrElse(defaultValue) {
+        return this.value == null ? defaultValue : this.value;
+    }
+    /**
+     * Returns the value or null
+     */
+    getOrNull() {
+        return this.value == null ? null : this.value;
+    }
+    /**
+     * Checks if the Maybe has a value
+     */
+    isSome() {
+        return this.value != null;
+    }
+    /**
+     * Checks if the Maybe has no value
+     */
+    isNone() {
+        return this.value == null;
+    }
+}
+/**
+ * Helper function to create a Maybe
+ */
+export const maybe = (value) => Maybe.of(value);
+/**
+ * Applies a function only if the condition is true
+ *
+ * @param condition - The condition to check
+ * @param fn - The function to apply
+ * @returns A function that conditionally applies the transformation
+ */
+export function when(condition, fn) {
+    return condition ? fn : (value) => value;
+}
+/**
+ * Applies a function only if the predicate returns true
+ *
+ * @param predicate - The predicate function
+ * @param fn - The function to apply
+ * @returns A function that conditionally applies the transformation
+ */
+export function whenPredicate(predicate, fn) {
+    return (value) => (predicate(value) ? fn(value) : value);
+}

package/dist/shared/utils/file.d.ts

@@ -0,0 +1,92 @@
+import { Result } from 'neverthrow'
+export type FileError =
+  | {
+      type: 'FILE_NOT_FOUND'
+      message: string
+    }
+  | {
+      type: 'PERMISSION_DENIED'
+      message: string
+    }
+  | {
+      type: 'WRITE_ERROR'
+      message: string
+    }
+  | {
+      type: 'READ_ERROR'
+      message: string
+    }
+  | {
+      type: 'DIRECTORY_ERROR'
+      message: string
+    }
+/**
+ * Read file synchronously
+ */
+export declare function readFileSync(filePath: string): Result<string, FileError>
+/**
+ * Read file asynchronously
+ */
+export declare function readFileAsync(filePath: string): Promise<Result<string, FileError>>
+/**
+ * Write file synchronously
+ */
+export declare function writeFileSync(filePath: string, content: string): Result<void, FileError>
+/**
+ * Write file asynchronously
+ */
+export declare function writeFileAsync(
+  filePath: string,
+  content: string,
+): Promise<Result<void, FileError>>
+/**
+ * Create directory
+ */
+export declare function ensureDirectorySync(dirPath: string): Result<void, FileError>
+/**
+ * Create directory asynchronously
+ */
+export declare function ensureDirectoryAsync(dirPath: string): Promise<Result<void, FileError>>
+/**
+ * Check if file exists
+ */
+export declare function fileExists(filePath: string): boolean
+/**
+ * Get directory path from file path
+ */
+export declare function getDirectoryPath(filePath: string): string
+/**
+ * Write file safely (including directory creation)
+ */
+export declare function safeWriteFileSync(
+  filePath: string,
+  content: string,
+): Result<void, FileError>
+/**
+ * Write file safely asynchronously (including directory creation)
+ */
+export declare function safeWriteFileAsync(
+  filePath: string,
+  content: string,
+): Promise<Result<void, FileError>>
+/**
+ * Function to transform file content
+ */
+export declare function transformFileContent<T>(
+  content: string,
+  transformer: (content: string) => Result<T, FileError>,
+): Result<T, FileError>
+/**
+ * Read file, transform it, and return result
+ */
+export declare function readAndTransformFileSync<T>(
+  filePath: string,
+  transformer: (content: string) => Result<T, FileError>,
+): Result<T, FileError>
+/**
+ * Read file asynchronously, transform it, and return result
+ */
+export declare function readAndTransformFileAsync<T>(
+  filePath: string,
+  transformer: (content: string) => Promise<Result<T, FileError>>,
+): Promise<Result<T, FileError>>

package/dist/shared/utils/file.js

@@ -0,0 +1,177 @@
+// Test run
+// pnpm vitest run src/shared/utils/file.test.ts
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { Result, ok, err } from 'neverthrow';
+import { tryCatch, tryCatchAsync } from './functional.js';
+/**
+ * Read file synchronously
+ */
+export function readFileSync(filePath) {
+    return tryCatch(() => fs.readFileSync(filePath, 'utf-8'), (error) => {
+        const err = error;
+        if (err.code === 'ENOENT') {
+            return {
+                type: 'FILE_NOT_FOUND',
+                message: `File not found: ${filePath}`,
+            };
+        }
+        if (err.code === 'EACCES') {
+            return {
+                type: 'PERMISSION_DENIED',
+                message: `Permission denied: ${filePath}`,
+            };
+        }
+        return {
+            type: 'READ_ERROR',
+            message: `Failed to read file: ${filePath} - ${err.message}`,
+        };
+    });
+}
+/**
+ * Read file asynchronously
+ */
+export async function readFileAsync(filePath) {
+    return tryCatchAsync(() => fsp.readFile(filePath, 'utf-8'), (error) => {
+        const err = error;
+        if (err.code === 'ENOENT') {
+            return {
+                type: 'FILE_NOT_FOUND',
+                message: `File not found: ${filePath}`,
+            };
+        }
+        if (err.code === 'EACCES') {
+            return {
+                type: 'PERMISSION_DENIED',
+                message: `Permission denied: ${filePath}`,
+            };
+        }
+        return {
+            type: 'READ_ERROR',
+            message: `Failed to read file: ${filePath} - ${err.message}`,
+        };
+    });
+}
+/**
+ * Write file synchronously
+ */
+export function writeFileSync(filePath, content) {
+    return tryCatch(() => fs.writeFileSync(filePath, content, 'utf-8'), (error) => {
+        const err = error;
+        if (err.code === 'EACCES') {
+            return {
+                type: 'PERMISSION_DENIED',
+                message: `Permission denied: ${filePath}`,
+            };
+        }
+        return {
+            type: 'WRITE_ERROR',
+            message: `Failed to write file: ${filePath} - ${err.message}`,
+        };
+    });
+}
+/**
+ * Write file asynchronously
+ */
+export async function writeFileAsync(filePath, content) {
+    return tryCatchAsync(() => fsp.writeFile(filePath, content, 'utf-8'), (error) => {
+        const err = error;
+        if (err.code === 'EACCES') {
+            return {
+                type: 'PERMISSION_DENIED',
+                message: `Permission denied: ${filePath}`,
+            };
+        }
+        return {
+            type: 'WRITE_ERROR',
+            message: `Failed to write file: ${filePath} - ${err.message}`,
+        };
+    });
+}
+/**
+ * Create directory
+ */
+export function ensureDirectorySync(dirPath) {
+    return tryCatch(() => {
+        fs.mkdirSync(dirPath, { recursive: true });
+        return undefined;
+    }, (error) => {
+        const err = error;
+        return {
+            type: 'DIRECTORY_ERROR',
+            message: `Failed to create directory: ${dirPath} - ${err.message}`,
+        };
+    });
+}
+/**
+ * Create directory asynchronously
+ */
+export async function ensureDirectoryAsync(dirPath) {
+    return tryCatchAsync(async () => {
+        await fsp.mkdir(dirPath, { recursive: true });
+        return undefined;
+    }, (error) => {
+        const err = error;
+        return {
+            type: 'DIRECTORY_ERROR',
+            message: `Failed to create directory: ${dirPath} - ${err.message}`,
+        };
+    });
+}
+/**
+ * Check if file exists
+ */
+export function fileExists(filePath) {
+    return fs.existsSync(filePath);
+}
+/**
+ * Get directory path from file path
+ */
+export function getDirectoryPath(filePath) {
+    return path.dirname(filePath);
+}
+/**
+ * Write file safely (including directory creation)
+ */
+export function safeWriteFileSync(filePath, content) {
+    const dirPath = getDirectoryPath(filePath);
+    const createDirResult = ensureDirectorySync(dirPath);
+    if (createDirResult.isErr()) {
+        return createDirResult;
+    }
+    return writeFileSync(filePath, content);
+}
+/**
+ * Write file safely asynchronously (including directory creation)
+ */
+export async function safeWriteFileAsync(filePath, content) {
+    const dirPath = getDirectoryPath(filePath);
+    const createDirResult = await ensureDirectoryAsync(dirPath);
+    if (createDirResult.isErr()) {
+        return createDirResult;
+    }
+    return writeFileAsync(filePath, content);
+}
+/**
+ * Function to transform file content
+ */
+export function transformFileContent(content, transformer) {
+    return transformer(content);
+}
+/**
+ * Read file, transform it, and return result
+ */
+export function readAndTransformFileSync(filePath, transformer) {
+    return readFileSync(filePath).andThen(transformer);
+}
+/**
+ * Read file asynchronously, transform it, and return result
+ */
+export async function readAndTransformFileAsync(filePath, transformer) {
+    const readResult = await readFileAsync(filePath);
+    if (readResult.isErr()) {
+        return err(readResult.error);
+    }
+    return transformer(readResult.value);
+}

package/dist/shared/utils/functional.d.ts

@@ -0,0 +1,118 @@
+import { Result } from 'neverthrow'
+/**
+ * Functional programming utility functions
+ */
+/**
+ * Compose functions (right to left)
+ * compose(f, g)(x) = f(g(x))
+ */
+export declare function compose<A, B, C>(f: (b: B) => C, g: (a: A) => B): (a: A) => C
+/**
+ * Pipeline functions (left to right)
+ * pipe(x, f, g) = g(f(x))
+ */
+export declare function pipe<A>(value: A): A
+export declare function pipe<A, B>(value: A, f1: (a: A) => B): B
+export declare function pipe<A, B, C>(value: A, f1: (a: A) => B, f2: (b: B) => C): C
+export declare function pipe<A, B, C, D>(
+  value: A,
+  f1: (a: A) => B,
+  f2: (b: B) => C,
+  f3: (c: C) => D,
+): D
+export declare function pipe<A, B, C, D, E>(
+  value: A,
+  f1: (a: A) => B,
+  f2: (b: B) => C,
+  f3: (c: C) => D,
+  f4: (d: D) => E,
+): E
+export declare function pipe<T>(value: T, ...fns: Array<(x: T) => T>): T
+export declare function pipe<T, U>(value: T, f1: (x: T) => U, ...fns: Array<(x: U) => U>): U
+/**
+ * Function composition using Result type
+ */
+export declare function composeResult<A, B, C, E>(
+  f: (b: B) => Result<C, E>,
+  g: (a: A) => Result<B, E>,
+): (a: A) => Result<C, E>
+/**
+ * Pipeline processing using Result type
+ */
+export declare function pipeResult<A, E>(value: Result<A, E>): Result<A, E>
+export declare function pipeResult<A, B, E>(
+  value: Result<A, E>,
+  f1: (a: A) => Result<B, E>,
+): Result<B, E>
+export declare function pipeResult<A, B, C, E>(
+  value: Result<A, E>,
+  f1: (a: A) => Result<B, E>,
+  f2: (b: B) => Result<C, E>,
+): Result<C, E>
+export declare function pipeResult<A, B, C, D, E>(
+  value: Result<A, E>,
+  f1: (a: A) => Result<B, E>,
+  f2: (b: B) => Result<C, E>,
+  f3: (c: C) => Result<D, E>,
+): Result<D, E>
+export declare function pipeResult<A, B, C, D, F, E>(
+  value: Result<A, E>,
+  f1: (a: A) => Result<B, E>,
+  f2: (b: B) => Result<C, E>,
+  f3: (c: C) => Result<D, E>,
+  f4: (d: D) => Result<F, E>,
+): Result<F, E>
+/**
+ * Wrap operations with side effects in Result type
+ */
+export declare function tryCatch<T, E = Error>(
+  fn: () => T,
+  errorHandler?: (error: unknown) => E,
+): Result<T, E>
+/**
+ * Wrap asynchronous operations with side effects in Result type
+ */
+export declare function tryCatchAsync<T, E = Error>(
+  fn: () => Promise<T>,
+  errorHandler?: (error: unknown) => E,
+): Promise<Result<T, E>>
+/**
+ * Apply Result type function to each element of array, return result only if all succeed
+ */
+export declare function mapResult<A, B, E>(
+  items: A[],
+  fn: (item: A) => Result<B, E>,
+): Result<B[], E>
+/**
+ * Return Result type based on condition
+ */
+export declare function fromPredicate<T, E>(
+  predicate: (value: T) => boolean,
+  value: T,
+  errorFactory: (value: T) => E,
+): Result<T, E>
+/**
+ * Maybe-like null/undefined check
+ */
+export declare function fromNullable<T, E>(
+  value: T | null | undefined,
+  errorFactory: () => E,
+): Result<T, E>
+/**
+ * Combine multiple Result types
+ */
+export declare function combine<T1, T2, E>(
+  r1: Result<T1, E>,
+  r2: Result<T2, E>,
+): Result<[T1, T2], E>
+export declare function combine<T1, T2, T3, E>(
+  r1: Result<T1, E>,
+  r2: Result<T2, E>,
+  r3: Result<T3, E>,
+): Result<[T1, T2, T3], E>
+export declare function combine<T1, T2, T3, T4, E>(
+  r1: Result<T1, E>,
+  r2: Result<T2, E>,
+  r3: Result<T3, E>,
+  r4: Result<T4, E>,
+): Result<[T1, T2, T3, T4], E>

package/dist/shared/utils/functional.js

@@ -0,0 +1,96 @@
+// Test run
+// pnpm vitest run src/shared/utils/functional.test.ts
+import { Result, ok, err } from 'neverthrow';
+/**
+ * Functional programming utility functions
+ */
+/**
+ * Compose functions (right to left)
+ * compose(f, g)(x) = f(g(x))
+ */
+export function compose(f, g) {
+    return (a) => f(g(a));
+}
+export function pipe(value, ...fns) {
+    return fns.reduce((acc, fn) => fn(acc), value);
+}
+/**
+ * Function composition using Result type
+ */
+export function composeResult(f, g) {
+    return (a) => g(a).andThen(f);
+}
+export function pipeResult(value, ...fns) {
+    return fns.reduce((acc, fn) => acc.andThen(fn), value);
+}
+/**
+ * Wrap operations with side effects in Result type
+ */
+export function tryCatch(fn, errorHandler) {
+    try {
+        return ok(fn());
+    }
+    catch (error) {
+        if (errorHandler) {
+            return err(errorHandler(error));
+        }
+        if (error instanceof Error) {
+            return err(error);
+        }
+        return err(new Error(String(error)));
+    }
+}
+/**
+ * Wrap asynchronous operations with side effects in Result type
+ */
+export async function tryCatchAsync(fn, errorHandler) {
+    try {
+        const result = await fn();
+        return ok(result);
+    }
+    catch (error) {
+        if (errorHandler) {
+            return err(errorHandler(error));
+        }
+        if (error instanceof Error) {
+            return err(error);
+        }
+        return err(new Error(String(error)));
+    }
+}
+/**
+ * Apply Result type function to each element of array, return result only if all succeed
+ */
+export function mapResult(items, fn) {
+    const results = [];
+    for (const item of items) {
+        const result = fn(item);
+        if (result.isErr()) {
+            return err(result.error);
+        }
+        results.push(result.value);
+    }
+    return ok(results);
+}
+/**
+ * Return Result type based on condition
+ */
+export function fromPredicate(predicate, value, errorFactory) {
+    return predicate(value) ? ok(value) : err(errorFactory(value));
+}
+/**
+ * Maybe-like null/undefined check
+ */
+export function fromNullable(value, errorFactory) {
+    return value != null ? ok(value) : err(errorFactory());
+}
+export function combine(...results) {
+    const values = [];
+    for (const result of results) {
+        if (result.isErr()) {
+            return err(result.error);
+        }
+        values.push(result.value);
+    }
+    return ok(values);
+}

package/dist/shared/utils/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Capitalize the first letter of a string.
+ *
+ * @param str - The input string.
+ * @returns A new string with the first letter capitalized.
+ */
+export declare function capitalize(str: string): string;
+export declare function schemaName(str: string): string;
+/**
+ * Parse field comments and extract definition line and description.
+ *
+ * @param commentLines - Raw comment lines (e.g., from source text)
+ * @param tag - The tag to look for (e.g., '@v.' or '@z.')
+ * @returns Parsed definition and description
+ */
+export declare function parseFieldComments(commentLines: string[], tag: '@v.' | '@z.'): {
+    definition: string;
+    description?: string;
+};
+export declare function extractFieldComments(sourceText: string, fieldStartPos: number): string[];

package/dist/shared/utils/index.js

@@ -0,0 +1,48 @@
+/**
+ * Capitalize the first letter of a string.
+ *
+ * @param str - The input string.
+ * @returns A new string with the first letter capitalized.
+ */
+export function capitalize(str) {
+    return `${str.charAt(0).toUpperCase()}${str.slice(1)}`;
+}
+export function schemaName(str) {
+    return `${str.charAt(0).toUpperCase() + str.slice(1)}Schema`;
+}
+/**
+ * Parse field comments and extract definition line and description.
+ *
+ * @param commentLines - Raw comment lines (e.g., from source text)
+ * @param tag - The tag to look for (e.g., '@v.' or '@z.')
+ * @returns Parsed definition and description
+ */
+export function parseFieldComments(commentLines, tag) {
+    const cleaned = commentLines.map((line) => line.replace(/^\/\/\/\s*/, '').trim()).filter(Boolean);
+    const definition = cleaned.find((line) => line.startsWith(tag))?.replace(/^@/, '') ?? '';
+    const descriptionLines = cleaned.filter((line) => !(line.includes('@z.') || line.includes('@v.') || line.includes('@relation.')));
+    const description = descriptionLines.length ? descriptionLines.join(' ') : undefined;
+    return { definition, description };
+}
+export function extractFieldComments(sourceText, fieldStartPos) {
+    const beforeField = sourceText.substring(0, fieldStartPos);
+    const lines = beforeField.split('\n');
+    const reverseIndex = lines
+        .map((line, index) => ({ line: line.trim(), index }))
+        .reverse()
+        .reduce((acc, { line }) => {
+        if (acc.shouldStop)
+            return acc;
+        if (line.startsWith('///')) {
+            return {
+                commentLines: [line, ...acc.commentLines],
+                shouldStop: false,
+            };
+        }
+        if (line === '') {
+            return acc;
+        }
+        return { commentLines: acc.commentLines, shouldStop: true };
+    }, { commentLines: [], shouldStop: false });
+    return reverseIndex.commentLines;
+}

package/dist/shared/utils/string-utils.d.ts

@@ -0,0 +1,8 @@
+export declare const capitalize: (str: string) => string;
+export declare const toPascalCase: (str: string) => string;
+export declare const extractComment: (commentText: string) => string;
+export declare const parseZodTag: (tag: string) => string;
+export declare const parseValibotTag: (tag: string) => string;
+export declare const parseRelationTag: (tag: string) => string;
+export declare const splitLines: (text: string) => string[];
+export declare const joinLines: (lines: string[]) => string;