sizuku 0.3.2 → 0.4.0

package/dist/shared/helper/find-object-literalIn-args.js

@@ -1,8 +0,0 @@
-export function findObjectLiteralInArgs(call, finder) {
-    for (const arg of call.getArguments()) {
-        const obj = finder(arg);
-        if (obj)
-            return obj;
-    }
-    return null;
-}

package/dist/shared/helper/is-relation-function.d.ts

@@ -1,10 +0,0 @@
-import type { CallExpression } from 'ts-morph';
-/**
- * Determines whether a given `CallExpression` is a relation-related function call.
- *
- * This checks if the function name is either `"relations"` or contains the substring `"relation"`.
- *
- * @param callExpr - The call expression node to check.
- * @returns `true` if the function is a relation function; otherwise, `false`.
- */
-export declare function isRelationFunctionCall(callExpr: CallExpression): boolean;

package/dist/shared/helper/is-relation-function.js

@@ -1,16 +0,0 @@
-import { Node } from 'ts-morph';
-/**
- * Determines whether a given `CallExpression` is a relation-related function call.
- *
- * This checks if the function name is either `"relations"` or contains the substring `"relation"`.
- *
- * @param callExpr - The call expression node to check.
- * @returns `true` if the function is a relation function; otherwise, `false`.
- */
-export function isRelationFunctionCall(callExpr) {
-    const expression = callExpr.getExpression();
-    if (!Node.isIdentifier(expression))
-        return false;
-    const functionName = expression.getText();
-    return functionName === 'relations' || functionName.includes('relation');
-}

package/dist/shared/types.d.ts

@@ -1,9 +0,0 @@
-export type SchemaField = {
-    name: string;
-    definition: string;
-    description?: string;
-};
-export type Schema = {
-    name: string;
-    fields: SchemaField[];
-};

package/dist/shared/types.js

@@ -1 +0,0 @@
-export {};

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

@@ -1,18 +0,0 @@
-/**
- * Capitalizes the first letter of a string
- *
- * @function capitalize
- * @param str - String to capitalize
- * @returns String with first letter capitalized
- *
- * @example
- * capitalize('posts')    // Returns: 'Posts'
- * capitalize('user')     // Returns: 'User'
- * capitalize('api')      // Returns: 'Api'
- *
- * @remarks
- * - Leaves rest of the string unchanged
- * - Returns empty string if input is empty
- * - Commonly used for generating type names and class names
- */
-export declare function capitalize(str: string): string;

package/dist/shared/utils/capitalize.js

@@ -1,20 +0,0 @@
-/**
- * Capitalizes the first letter of a string
- *
- * @function capitalize
- * @param str - String to capitalize
- * @returns String with first letter capitalized
- *
- * @example
- * capitalize('posts')    // Returns: 'Posts'
- * capitalize('user')     // Returns: 'User'
- * capitalize('api')      // Returns: 'Api'
- *
- * @remarks
- * - Leaves rest of the string unchanged
- * - Returns empty string if input is empty
- * - Commonly used for generating type names and class names
- */
-export function capitalize(str) {
-    return `${str.charAt(0).toUpperCase()}${str.slice(1)}`;
-}

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

@@ -1,101 +0,0 @@
-/**
- * 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 declare function pipe<T>(value: T, ...fns: Array<(arg: any) => any>): any
-/**
- * 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 declare function compose<T>(...fns: Array<(arg: any) => any>): (arg: T) => any
-/**
- * Maybe monad for handling nullable values
- *
- * @template T - The wrapped value type
- */
-export declare class Maybe<T> {
-  private value
-  private constructor()
-  /**
-   * Creates a Maybe from a value
-   */
-  static of<T>(value: T | null | undefined): Maybe<T>
-  /**
-   * Creates a Maybe with no value
-   */
-  static none<T>(): Maybe<T>
-  /**
-   * Maps a function over the Maybe value
-   */
-  map<U>(fn: (value: T) => U): Maybe<U>
-  /**
-   * Flat maps a function that returns a Maybe
-   */
-  flatMap<U>(fn: (value: T) => Maybe<U>): Maybe<U>
-  /**
-   * Returns the value or a default
-   */
-  getOrElse(defaultValue: T): T
-  /**
-   * Returns the value or null
-   */
-  getOrNull(): T | null
-  /**
-   * Checks if the Maybe has a value
-   */
-  isSome(): boolean
-  /**
-   * Checks if the Maybe has no value
-   */
-  isNone(): boolean
-}
-/**
- * Helper function to create a Maybe
- */
-export declare const maybe: <T>(value: T | null | undefined) => Maybe<T>
-/**
- * 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 declare function when<T>(condition: boolean, fn: (value: T) => T): (value: T) => T
-/**
- * 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 declare function whenPredicate<T>(
-  predicate: (value: T) => boolean,
-  fn: (value: T) => T,
-): (value: T) => T

package/dist/shared/utils/compose.js

@@ -1,124 +0,0 @@
-/**
- * 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

@@ -1,92 +0,0 @@
-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

@@ -1,177 +0,0 @@
-// 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

@@ -1,118 +0,0 @@
-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>