zod-codegen 1.4.0 → 1.4.1

package/dist/tests/unit/naming-convention.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=naming-convention.test.d.ts.map

package/dist/tests/unit/naming-convention.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"naming-convention.test.d.ts","sourceRoot":"","sources":["../../../tests/unit/naming-convention.test.ts"],"names":[],"mappings":""}

package/dist/tests/unit/naming-convention.test.js

@@ -1,231 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { transformNamingConvention } from '../../src/utils/naming-convention.js';
-describe('transformNamingConvention', () => {
-    describe('transform', () => {
-        const testCases = [
-            // camelCase
-            {
-                input: 'get_user_by_id',
-                convention: 'camelCase',
-                expected: 'getUserById',
-                description: 'should convert snake_case to camelCase',
-            },
-            {
-                input: 'GetUserById',
-                convention: 'camelCase',
-                expected: 'getUserById',
-                description: 'should convert PascalCase to camelCase',
-            },
-            {
-                input: 'get-user-by-id',
-                convention: 'camelCase',
-                expected: 'getUserById',
-                description: 'should convert kebab-case to camelCase',
-            },
-            {
-                input: 'getUserById',
-                convention: 'camelCase',
-                expected: 'getUserById',
-                description: 'should keep camelCase as camelCase',
-            },
-            // PascalCase
-            {
-                input: 'get_user_by_id',
-                convention: 'PascalCase',
-                expected: 'GetUserById',
-                description: 'should convert snake_case to PascalCase',
-            },
-            {
-                input: 'get-user-by-id',
-                convention: 'PascalCase',
-                expected: 'GetUserById',
-                description: 'should convert kebab-case to PascalCase',
-            },
-            {
-                input: 'getUserById',
-                convention: 'PascalCase',
-                expected: 'GetUserById',
-                description: 'should convert camelCase to PascalCase',
-            },
-            // snake_case
-            {
-                input: 'getUserById',
-                convention: 'snake_case',
-                expected: 'get_user_by_id',
-                description: 'should convert camelCase to snake_case',
-            },
-            {
-                input: 'GetUserById',
-                convention: 'snake_case',
-                expected: 'get_user_by_id',
-                description: 'should convert PascalCase to snake_case',
-            },
-            {
-                input: 'get-user-by-id',
-                convention: 'snake_case',
-                expected: 'get_user_by_id',
-                description: 'should convert kebab-case to snake_case',
-            },
-            // kebab-case
-            {
-                input: 'getUserById',
-                convention: 'kebab-case',
-                expected: 'get-user-by-id',
-                description: 'should convert camelCase to kebab-case',
-            },
-            {
-                input: 'GetUserById',
-                convention: 'kebab-case',
-                expected: 'get-user-by-id',
-                description: 'should convert PascalCase to kebab-case',
-            },
-            {
-                input: 'get_user_by_id',
-                convention: 'kebab-case',
-                expected: 'get-user-by-id',
-                description: 'should convert snake_case to kebab-case',
-            },
-            // SCREAMING_SNAKE_CASE
-            {
-                input: 'getUserById',
-                convention: 'SCREAMING_SNAKE_CASE',
-                expected: 'GET_USER_BY_ID',
-                description: 'should convert camelCase to SCREAMING_SNAKE_CASE',
-            },
-            {
-                input: 'get-user-by-id',
-                convention: 'SCREAMING_SNAKE_CASE',
-                expected: 'GET_USER_BY_ID',
-                description: 'should convert kebab-case to SCREAMING_SNAKE_CASE',
-            },
-            // SCREAMING-KEBAB-CASE
-            {
-                input: 'getUserById',
-                convention: 'SCREAMING-KEBAB-CASE',
-                expected: 'GET-USER-BY-ID',
-                description: 'should convert camelCase to SCREAMING-KEBAB-CASE',
-            },
-            {
-                input: 'get_user_by_id',
-                convention: 'SCREAMING-KEBAB-CASE',
-                expected: 'GET-USER-BY-ID',
-                description: 'should convert snake_case to SCREAMING-KEBAB-CASE',
-            },
-            // Edge cases
-            {
-                input: '',
-                convention: 'camelCase',
-                expected: '',
-                description: 'should handle empty string',
-            },
-            {
-                input: 'a',
-                convention: 'camelCase',
-                expected: 'a',
-                description: 'should handle single character',
-            },
-            {
-                input: 'API',
-                convention: 'camelCase',
-                expected: 'aPI',
-                description: 'should handle all uppercase (splits at uppercase boundaries)',
-            },
-            {
-                input: 'getUser123ById',
-                convention: 'snake_case',
-                expected: 'get_user_123_by_id',
-                description: 'should handle numbers in identifiers (splits at digit boundaries)',
-            },
-        ];
-        testCases.forEach(({ input, convention, expected, description }) => {
-            it(description, () => {
-                const result = transformNamingConvention(input, convention);
-                expect(result).toBe(expected);
-            });
-        });
-    });
-    describe('edge cases', () => {
-        describe('consecutive delimiters', () => {
-            it('should handle consecutive underscores', () => {
-                expect(transformNamingConvention('get__user__by__id', 'camelCase')).toBe('getUserById');
-            });
-            it('should handle consecutive hyphens', () => {
-                expect(transformNamingConvention('get--user--by--id', 'snake_case')).toBe('get_user_by_id');
-            });
-            it('should handle mixed consecutive delimiters', () => {
-                expect(transformNamingConvention('get__user--by_id', 'kebab-case')).toBe('get-user-by-id');
-            });
-        });
-        describe('mixed delimiters', () => {
-            it('should handle snake_case and kebab-case mixed', () => {
-                // Note: Delimiters split the string, so 'byId' becomes 'by' and 'id' (normalized to lowercase)
-                expect(transformNamingConvention('get_user-byId', 'camelCase')).toBe('getUserByid');
-            });
-            it('should handle camelCase with underscores', () => {
-                // Note: Underscore delimiter splits, so 'byId' becomes 'by' and 'id'
-                expect(transformNamingConvention('getUser_byId', 'PascalCase')).toBe('GetuserByid');
-            });
-            it('should handle dots as delimiters', () => {
-                expect(transformNamingConvention('get.user.by.id', 'snake_case')).toBe('get_user_by_id');
-            });
-            it('should handle spaces as delimiters', () => {
-                expect(transformNamingConvention('get user by id', 'kebab-case')).toBe('get-user-by-id');
-            });
-        });
-        describe('unicode and special characters', () => {
-            it('should handle accented characters', () => {
-                expect(transformNamingConvention('getRésumé', 'snake_case')).toBe('get_résumé');
-            });
-            it('should handle numbers at start', () => {
-                expect(transformNamingConvention('123getUser', 'camelCase')).toBe('123getUser');
-            });
-            it('should handle single uppercase letter', () => {
-                expect(transformNamingConvention('getX', 'snake_case')).toBe('get_x');
-            });
-            it('should handle all numbers', () => {
-                expect(transformNamingConvention('123456', 'camelCase')).toBe('123456');
-            });
-        });
-        describe('acronyms and abbreviations', () => {
-            it('should handle acronyms in camelCase (splits on uppercase boundaries)', () => {
-                // Note: Algorithm splits on uppercase boundaries, so 'XML' becomes 'X', 'M', 'L'
-                // This is correct behavior - detecting acronyms would require a dictionary
-                expect(transformNamingConvention('getXMLData', 'snake_case')).toBe('get_x_m_l_data');
-            });
-            it('should handle multiple acronyms (splits on uppercase boundaries)', () => {
-                // Note: 'JSON' and 'XML' are split into individual letters
-                // 'parseJSONToXML' → ['parse', 'j', 's', 'o', 'n', 'to', 'x', 'm', 'l']
-                expect(transformNamingConvention('parseJSONToXML', 'kebab-case')).toBe('parse-j-s-o-n-to-x-m-l');
-            });
-            it('should handle ID abbreviation (splits on uppercase boundaries)', () => {
-                // Note: 'ID' is split into 'I' and 'D' because the algorithm splits on uppercase boundaries
-                // This is correct behavior - detecting acronyms would require a dictionary
-                expect(transformNamingConvention('getUserID', 'snake_case')).toBe('get_user_i_d');
-            });
-        });
-        describe('already transformed names', () => {
-            it('should be idempotent for camelCase', () => {
-                const input = 'getUserById';
-                const result = transformNamingConvention(input, 'camelCase');
-                expect(transformNamingConvention(result, 'camelCase')).toBe(result);
-            });
-            it('should be idempotent for snake_case', () => {
-                const input = 'get_user_by_id';
-                const result = transformNamingConvention(input, 'snake_case');
-                expect(transformNamingConvention(result, 'snake_case')).toBe(result);
-            });
-        });
-        describe('special patterns', () => {
-            it('should handle single word', () => {
-                expect(transformNamingConvention('user', 'PascalCase')).toBe('User');
-            });
-            it('should handle two words', () => {
-                expect(transformNamingConvention('getUser', 'snake_case')).toBe('get_user');
-            });
-            it('should handle very long names', () => {
-                const longName = 'getVeryLongOperationNameWithManyWords';
-                expect(transformNamingConvention(longName, 'kebab-case')).toBe('get-very-long-operation-name-with-many-words');
-            });
-        });
-    });
-});

package/scripts/republish-versions.sh

@@ -1,94 +0,0 @@
-#!/bin/bash
-
-# Script to republish missing versions to npm
-# Usage: ./scripts/republish-versions.sh [version1] [version2]
-# Example: ./scripts/republish-versions.sh 1.3.0 1.4.0
-
-set -e
-
-# Colors for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-NC='\033[0m' # No Color
-
-# Function to publish a version
-publish_version() {
-    local version=$1
-    local tag="v${version}"
-    
-    echo -e "${YELLOW}📦 Publishing version ${version}...${NC}"
-    
-    # Check if tag exists
-    if ! git rev-parse "$tag" >/dev/null 2>&1; then
-        echo -e "${RED}❌ Tag ${tag} does not exist${NC}"
-        return 1
-    fi
-    
-    # Check if version is already published
-    if npm view "zod-codegen@${version}" version >/dev/null 2>&1; then
-        echo -e "${YELLOW}⚠️  Version ${version} already exists on npm. Skipping...${NC}"
-        return 0
-    fi
-    
-    # Save current branch/commit
-    local current_branch=$(git rev-parse --abbrev-ref HEAD)
-    local current_commit=$(git rev-parse HEAD)
-    
-    echo -e "${GREEN}✓ Checking out tag ${tag}${NC}"
-    git checkout "$tag" --quiet
-    
-    # Verify package.json version matches
-    local package_version=$(node -p "require('./package.json').version")
-    if [ "$package_version" != "$version" ]; then
-        echo -e "${RED}❌ Package.json version (${package_version}) doesn't match tag version (${version})${NC}"
-        git checkout "$current_branch" --quiet 2>/dev/null || git checkout "$current_commit" --quiet
-        return 1
-    fi
-    
-    # Install dependencies
-    echo -e "${GREEN}✓ Installing dependencies...${NC}"
-    yarn install --frozen-lockfile
-    
-    # Build project
-    echo -e "${GREEN}✓ Building project...${NC}"
-    yarn build
-    
-    # Run prepublishOnly checks (build, test, lint, type-check)
-    echo -e "${GREEN}✓ Running prepublish checks...${NC}"
-    yarn test
-    yarn lint:check
-    yarn type-check
-    
-    # Publish to npm
-    echo -e "${GREEN}✓ Publishing to npm...${NC}"
-    npm publish --access public
-    
-    echo -e "${GREEN}✅ Successfully published version ${version}${NC}"
-    
-    # Return to original branch/commit
-    echo -e "${GREEN}✓ Returning to ${current_branch}...${NC}"
-    git checkout "$current_branch" --quiet 2>/dev/null || git checkout "$current_commit" --quiet
-    
-    echo ""
-}
-
-# Check if npm is authenticated
-if ! npm whoami >/dev/null 2>&1; then
-    echo -e "${RED}❌ Not authenticated to npm. Please run 'npm login' first.${NC}"
-    exit 1
-fi
-
-echo -e "${GREEN}✓ Authenticated as $(npm whoami)${NC}"
-echo ""
-
-# Get versions from arguments or use defaults
-VERSIONS=("${@:-1.3.0 1.4.0}")
-
-# Publish each version
-for version in "${VERSIONS[@]}"; do
-    publish_version "$version"
-done
-
-echo -e "${GREEN}🎉 All versions published successfully!${NC}"
-