@idealyst/cli 1.0.90 → 1.0.92

package/template/packages/database/README.md

@@ -0,0 +1,162 @@
+# Database Package
+
+This package provides database access and validation schemas for the workspace using Prisma ORM.
+
+## Setup
+
+1. Install dependencies:
+```bash
+yarn install
+```
+
+2. Set up your environment:
+```bash
+cp .env.example .env
+# Edit .env with your database URL
+```
+
+3. Generate the Prisma client:
+```bash
+yarn db:generate
+```
+
+4. Push the schema to your database:
+```bash
+yarn db:push
+```
+
+5. Seed the database with test data:
+```bash
+yarn db:seed
+```
+
+## Database Schema
+
+### Test Model
+
+The Test model is included for quick testing and API demonstration:
+
+```prisma
+model Test {
+  id        String   @id @default(cuid())
+  name      String
+  message   String
+  status    String   @default("active")
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+```
+
+#### Fields:
+- `id`: Unique identifier (CUID)
+- `name`: Test name/title
+- `message`: Test message content
+- `status`: Test status (defaults to "active")
+- `createdAt`: Record creation timestamp
+- `updatedAt`: Record last update timestamp
+
+### Sample Models
+
+The schema also includes comprehensive example models for reference:
+
+#### User Model
+- Complete user management with authentication fields
+- Email validation and profile information
+- Timestamps for tracking
+
+#### Post Model
+- Blog post or content management
+- User relationship for authorship
+- Publishing status and timestamps
+
+#### Comment Model
+- Comment system for posts
+- User and post relationships
+- Moderation support
+
+## Usage
+
+### In API Code
+
+```typescript
+import { db } from '@{{workspaceScope}}/database';
+
+// Create a test record
+const test = await db.test.create({
+  data: {
+    name: 'My Test',
+    message: 'This is a test message',
+    status: 'active'
+  }
+});
+
+// Get all tests
+const tests = await db.test.findMany();
+
+// Update a test
+const updatedTest = await db.test.update({
+  where: { id: 'test-id' },
+  data: { status: 'completed' }
+});
+```
+
+### Prisma Commands
+
+```bash
+# Generate client
+yarn prisma:generate
+
+# Run migrations
+yarn prisma:migrate
+
+# Reset database
+yarn prisma:reset
+
+# Seed database
+yarn prisma:seed
+
+# Open Prisma Studio
+yarn prisma:studio
+```
+
+## Quick Test
+
+The database includes a simple `Test` model for immediate testing:
+
+```typescript
+import { prisma } from '@{{workspaceScope}}/{{name}}';
+
+// Get all test entries
+const tests = await prisma.test.findMany();
+
+// Create a new test entry
+const newTest = await prisma.test.create({
+  data: {
+    name: 'My Test',
+    message: 'Testing the database connection',
+    status: 'active',
+  },
+});
+```
+
+## Usage
+
+```typescript
+import { prisma, User, TestValidator } from '@{{workspaceScope}}/{{name}}';
+
+// Use the database client
+const users = await prisma.user.findMany();
+
+// Use validators
+const validatedData = TestValidator.parse(userData);
+```
+
+## Scripts
+
+- `yarn db:generate` - Generate Prisma client
+- `yarn db:push` - Push schema to database
+- `yarn db:migrate` - Create and run migrations
+- `yarn db:studio` - Open Prisma Studio
+- `yarn db:reset` - Reset the database
+- `yarn build` - Build the package
+- `yarn dev` - Build in watch mode

package/template/packages/database/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@{{workspaceScope}}/database",
+  "version": "1.0.0",
+  "description": "Database layer with Prisma",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./generated/client/index.d.ts",
+      "import": "./generated/client/index.js",
+      "require": "./generated/client/index.js"
+    },
+    "./schemas": {
+      "types": "./dist/validators.d.ts",
+      "import": "./dist/validators.js",
+      "require": "./dist/validators.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "db:generate": "prisma generate",
+    "db:push": "prisma db push",
+    "db:migrate": "prisma migrate dev",
+    "db:studio": "prisma studio",
+    "db:seed": "tsx prisma/seed.ts",
+    "db:reset": "prisma migrate reset"
+  },
+  "dependencies": {
+    "@prisma/client": "^5.19.1",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "prisma": "^5.19.1",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3"
+  },
+  "files": [
+    "dist/**/*",
+    "prisma/**/*",
+    "generated/**/*"
+  ]
+}

package/template/packages/database/prisma/seed.ts

@@ -0,0 +1,64 @@
+import { PrismaClient } from '../generated/client';
+
+const prisma = new PrismaClient();
+
+async function main() {
+  // Add your seed data here
+  console.log('🌱 Seeding database...');
+  
+  // Create some test data for the Test model
+  console.log('📝 Creating test entries...');
+  
+  const testEntries = await Promise.all([
+    prisma.test.create({
+      data: {
+        name: 'API Connection Test',
+        message: 'This test verifies that the API can connect to the database successfully.',
+        status: 'active',
+      },
+    }),
+    prisma.test.create({
+      data: {
+        name: 'Data Validation Test',
+        message: 'This test ensures that data validation is working correctly across the stack.',
+        status: 'active',
+      },
+    }),
+    prisma.test.create({
+      data: {
+        name: 'tRPC Integration Test',
+        message: 'This test confirms that tRPC endpoints are properly configured and accessible.',
+        status: 'active',
+      },
+    }),
+    prisma.test.create({
+      data: {
+        name: 'Sample Inactive Test',
+        message: 'This is an example of an inactive test entry.',
+        status: 'inactive',
+      },
+    }),
+  ]);
+
+  console.log(`✅ Created ${testEntries.length} test entries`);
+  
+  // Example seed data for other models (uncommented for reference)
+  // const user = await prisma.user.create({
+  //   data: {
+  //     email: 'admin@example.com',
+  //     name: 'Admin User',
+  //   },
+  // });
+  
+  console.log('✅ Seeding completed');
+}
+
+main()
+  .then(async () => {
+    await prisma.$disconnect();
+  })
+  .catch(async (e) => {
+    console.error(e);
+    await prisma.$disconnect();
+    process.exit(1);
+  });

package/template/packages/database/schema.prisma

@@ -0,0 +1,107 @@
+// This is your Prisma schema file,
+// learn more about it in the docs: https://pris.ly/d/prisma-schema
+
+generator client {
+  provider = "prisma-client-js"
+  output   = "./generated/client"
+}
+
+datasource db {
+  provider = "postgres"
+  url      = env("DATABASE_URL")
+}
+
+// Simple Test model for quick API testing
+model Test {
+  id        String   @id @default(cuid())
+  name      String
+  message   String
+  status    String   @default("active") // "active", "inactive"
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+
+// Demo User model with profile information
+model User {
+  id        String   @id @default(cuid())
+  email     String   @unique
+  name      String?
+  avatar    String?  // URL to profile image
+  bio       String?  // User biography
+  location  String?  // User location
+  website   String?  // Personal website
+  
+  // Posts created by this user
+  posts     Post[]
+  
+  // Comments made by this user
+  comments  Comment[]
+  
+  // User preferences and settings
+  settings  UserSettings?
+  
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+
+// Demo Post model for a simple blog/social feed
+model Post {
+  id        String   @id @default(cuid())
+  title     String
+  content   String
+  excerpt   String?  // Short description
+  published Boolean  @default(false)
+  tags      String?  // Comma-separated tag strings
+  
+  // Author relationship
+  author    User     @relation(fields: [authorId], references: [id], onDelete: Cascade)
+  authorId  String
+  
+  // Comments on this post
+  comments  Comment[]
+  
+  // Post metadata
+  views     Int      @default(0)
+  likes     Int      @default(0)
+  
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+
+// Demo Comment model
+model Comment {
+  id        String   @id @default(cuid())
+  content   String
+  
+  // Author relationship
+  author    User     @relation(fields: [authorId], references: [id], onDelete: Cascade)
+  authorId  String
+  
+  // Post relationship
+  post      Post     @relation(fields: [postId], references: [id], onDelete: Cascade)
+  postId    String
+  
+  // Parent comment for nested threading
+  parent    Comment? @relation("CommentThread", fields: [parentId], references: [id])
+  parentId  String?
+  children  Comment[] @relation("CommentThread")
+  
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+}
+
+// User settings and preferences
+model UserSettings {
+  id               String  @id @default(cuid())
+  theme            String  @default("auto") // "light", "dark", "auto"
+  notifications    Boolean @default(true)
+  emailUpdates     Boolean @default(false)
+  publicProfile    Boolean @default(true)
+  
+  // User relationship (one-to-one)
+  user             User    @relation(fields: [userId], references: [id], onDelete: Cascade)
+  userId           String  @unique
+  
+  createdAt        DateTime @default(now())
+  updatedAt        DateTime @updatedAt
+}

package/template/packages/database/src/index.ts

@@ -0,0 +1,15 @@
+import { PrismaClient } from '../generated/client';
+
+declare global {
+  var __prisma: PrismaClient | undefined;
+}
+
+export const prisma = globalThis.__prisma || new PrismaClient();
+
+if (process.env.NODE_ENV !== 'production') {
+  globalThis.__prisma = prisma;
+}
+
+export * from './validators';
+export * from '../generated/client';
+export default prisma;

package/template/packages/database/src/validators.ts

@@ -0,0 +1,10 @@
+// Create model validators for each model defined in the Prisma schema using Zod
+// E.g
+import { z } from 'zod';
+
+export const TestValidator = z.object({
+  id: z.string().uuid(),
+  email: z.string().email(),
+  name: z.string().min(2).max(100),
+  age: z.number().min(0).optional()
+});

package/template/packages/database/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/template/packages/mobile/README.md

@@ -0,0 +1,86 @@
+# {{projectName}}
+
+{{description}}
+
+## Getting Started
+
+This is a React Native application built with the Idealyst Framework.
+
+### Prerequisites
+
+- Node.js 18+
+- Yarn
+- React Native development environment
+- Android Studio (for Android development)
+- Xcode (for iOS development)
+
+### Installation
+
+Install dependencies:
+```bash
+yarn install
+```
+
+### Running the App
+
+Start the Metro bundler:
+```bash
+yarn start
+```
+
+Run on Android:
+```bash
+yarn android
+```
+
+Run on iOS:
+```bash
+yarn ios
+```
+
+### Project Structure
+
+```
+{{projectName}}/
+├── src/
+│   └── App.tsx        # Main app component
+├── android/           # Android-specific code
+├── ios/               # iOS-specific code
+├── babel.config.js    # Babel configuration
+├── metro.config.js    # Metro configuration
+└── tsconfig.json      # TypeScript configuration
+```
+
+### Features
+
+- **Idealyst Components**: Pre-built UI components
+- **Idealyst Navigation**: Cross-platform navigation
+- **Idealyst Theme**: Consistent theming system
+- **TypeScript**: Full type safety
+- **React Native 0.80.1**: Latest stable version
+
+### Development
+
+The app uses the Idealyst Framework for consistent UI and navigation across platforms.
+
+Edit `src/App.tsx` to start building your application.
+
+### Building for Production
+
+Build Android APK:
+```bash
+yarn build:android
+```
+
+### Testing
+
+Run tests:
+```bash
+yarn test
+```
+
+### Learn More
+
+- [Idealyst Framework Documentation](https://github.com/your-username/idealyst-framework)
+- [React Native Documentation](https://reactnative.dev/)
+- [TypeScript Documentation](https://www.typescriptlang.org/) 

package/template/packages/mobile/__tests__/App.test.tsx

@@ -0,0 +1,156 @@
+/**
+ * @format
+ */
+
+import React from 'react';
+import ReactTestRenderer from 'react-test-renderer';
+import App from '../App';
+
+// Mock the NavigatorProvider to avoid complex navigation setup
+jest.mock('@idealyst/navigation', () => ({
+  NavigatorProvider: ({ children }: { children?: React.ReactNode }) => (
+    React.createElement('View', { testID: 'navigator-provider' }, children || 'Navigator Content')
+  ),
+}));
+
+jest.mock('@idealyst/navigation/examples', () => ({
+  ExampleStackRouter: {},
+}));
+
+describe('App Component', () => {
+  it('renders correctly', async () => {
+    let component: ReactTestRenderer.ReactTestRenderer;
+    
+    await ReactTestRenderer.act(() => {
+      component = ReactTestRenderer.create(<App />);
+    });
+    
+    expect(component!).toBeDefined();
+    expect(component!.toJSON()).toMatchSnapshot();
+  });
+
+  it('renders without crashing', () => {
+    const tree = ReactTestRenderer.create(<App />);
+    expect(tree).toBeDefined();
+    expect(tree.root).toBeDefined();
+  });
+
+  it('contains NavigatorProvider', () => {
+    const tree = ReactTestRenderer.create(<App />);
+    const navigatorProvider = tree.root.findByProps({ testID: 'navigator-provider' });
+    expect(navigatorProvider).toBeDefined();
+  });
+
+  it('has proper SafeAreaView structure', () => {
+    const tree = ReactTestRenderer.create(<App />);
+    const safeAreaView = tree.root.findByType('SafeAreaView');
+    expect(safeAreaView).toBeDefined();
+    expect(safeAreaView.props.style).toEqual({ flex: 1 });
+  });
+});
+
+describe('Sample Component Tests', () => {
+  // Example of testing a simple functional component
+  const SimpleButton = ({ title, onPress, disabled = false }: {
+    title: string;
+    onPress: () => void;
+    disabled?: boolean;
+  }) => {
+    return React.createElement(
+      'TouchableOpacity',
+      {
+        testID: 'simple-button',
+        onPress: disabled ? undefined : onPress,
+        style: { opacity: disabled ? 0.5 : 1 }
+      },
+      React.createElement('Text', null, title)
+    );
+  };
+
+  it('renders button with correct title', () => {
+    const mockPress = jest.fn();
+    const tree = ReactTestRenderer.create(
+      <SimpleButton title="Test Button" onPress={mockPress} />
+    );
+    
+    const textElement = tree.root.findByType('Text');
+    expect(textElement.children).toEqual(['Test Button']);
+  });
+
+  it('handles press events', () => {
+    const mockPress = jest.fn();
+    const tree = ReactTestRenderer.create(
+      <SimpleButton title="Test Button" onPress={mockPress} />
+    );
+    
+    const button = tree.root.findByProps({ testID: 'simple-button' });
+    ReactTestRenderer.act(() => {
+      button.props.onPress();
+    });
+    
+    expect(mockPress).toHaveBeenCalledTimes(1);
+  });
+
+  it('disables button when disabled prop is true', () => {
+    const mockPress = jest.fn();
+    const tree = ReactTestRenderer.create(
+      <SimpleButton title="Disabled Button" onPress={mockPress} disabled={true} />
+    );
+    
+    const button = tree.root.findByProps({ testID: 'simple-button' });
+    expect(button.props.onPress).toBeUndefined();
+    expect(button.props.style.opacity).toBe(0.5);
+  });
+
+  it('handles component state changes', () => {
+    const StatefulComponent = () => {
+      const [count, setCount] = React.useState(0);
+      
+      return React.createElement(
+        'View',
+        { testID: 'stateful-component' },
+        React.createElement('Text', { testID: 'count' }, count.toString()),
+        React.createElement(
+          'TouchableOpacity',
+          {
+            testID: 'increment-button',
+            onPress: () => setCount(c => c + 1)
+          },
+          React.createElement('Text', null, 'Increment')
+        )
+      );
+    };
+
+    const tree = ReactTestRenderer.create(<StatefulComponent />);
+    
+    // Check initial state
+    const countText = tree.root.findByProps({ testID: 'count' });
+    expect(countText.children).toEqual(['0']);
+    
+    // Simulate button press
+    const incrementButton = tree.root.findByProps({ testID: 'increment-button' });
+    ReactTestRenderer.act(() => {
+      incrementButton.props.onPress();
+    });
+    
+    // Check updated state
+    expect(countText.children).toEqual(['1']);
+  });
+});
+
+describe('Sample Native Tests', () => {
+  it('should pass a basic test', () => {
+    expect(1 + 1).toBe(2);
+  });
+
+  it('should handle string operations', () => {
+    const greeting = 'Hello World';
+    expect(greeting).toContain('World');
+  });
+
+  it('should work with arrays', () => {
+    const items = [1, 2, 3];
+    expect(items).toHaveLength(3);
+    expect(items).toContain(2);
+  });
+});