@slingr/cli 0.0.1

package/src/templates/src/Person.test.ts.template

@@ -0,0 +1,289 @@
+import { Person } from './Person';
+
+describe('Person Model', () => {
+  describe('Validation Tests', () => {
+    it('should validate a valid adult person', async () => {
+      const personData = {
+        additionalInfo: '<p>Some info</p>',
+        age: 25,
+        email: 'john@example.com',
+        firstName: 'John',
+        isActive: true,
+        lastName: 'Doe',
+        phoneNumber: '123-456-7890',
+      };
+
+      const person = Person.fromJSON(personData);
+      const errors = await person.validate();
+
+      expect(errors.length).toBe(0);
+    });
+
+    it('should validate a valid minor person with parent email', async () => {
+      const personData = {
+        additionalInfo: '<p>Minor info</p>',
+        age: 16,
+        email: 'jane@example.com',
+        firstName: 'Jane',
+        isActive: false,
+        lastName: 'Smith',
+        parentEmail: 'parent@example.com',
+      };
+
+      const person = Person.fromJSON(personData);
+      const errors = await person.validate();
+
+      expect(errors.length).toBe(0);
+    });
+
+    it('should fail validation when firstName is too short', async () => {
+      const personData = {
+        age: 25,
+        email: 'john@example.com',
+        firstName: 'J',
+        lastName: 'Doe',
+      };
+
+      const person = Person.fromJSON(personData);
+      const errors = await person.validate();
+
+      expect(errors.length).toBeGreaterThan(0);
+      const firstNameError = errors.find((e) => e.property === 'firstName');
+      expect(firstNameError).toBeDefined();
+      expect(firstNameError?.constraints).toHaveProperty('minLength');
+    });
+
+    it('should fail validation when firstName contains numbers', async () => {
+      const personData = {
+        age: 25,
+        email: 'john@example.com',
+        firstName: 'John123',
+        lastName: 'Doe',
+      };
+
+      const person = Person.fromJSON(personData);
+      const errors = await person.validate();
+
+      expect(errors.length).toBeGreaterThan(0);
+      const firstNameError = errors.find((e) => e.property === 'firstName');
+      expect(firstNameError).toBeDefined();
+      expect(firstNameError?.constraints).toHaveProperty('matches');
+    });
+
+    it('should fail validation when email is invalid', async () => {
+      const personData = {
+        age: 25,
+        email: 'invalid-email',
+        firstName: 'John',
+        lastName: 'Doe',
+      };
+
+      const person = Person.fromJSON(personData);
+      const errors = await person.validate();
+
+      expect(errors.length).toBeGreaterThan(0);
+      const emailError = errors.find((e) => e.property === 'email');
+      expect(emailError).toBeDefined();
+      expect(emailError?.constraints).toHaveProperty('isEmail');
+    });
+
+    it('should fail validation when age is negative', async () => {
+      const personData = {
+        age: -5,
+        email: 'john@example.com',
+        firstName: 'John',
+        lastName: 'Doe',
+      };
+
+      const person = Person.fromJSON(personData);
+      const errors = await person.validate();
+
+      expect(errors.length).toBeGreaterThan(0);
+      const ageError = errors.find((e) => e.property === 'age');
+      expect(ageError).toBeDefined();
+      expect(ageError?.constraints).toHaveProperty('invalidAge');
+    });
+
+    it('should fail validation when age is too high', async () => {
+      const personData = {
+        age: 150,
+        email: 'john@example.com',
+        firstName: 'John',
+        lastName: 'Doe',
+      };
+
+      const person = Person.fromJSON(personData);
+      const errors = await person.validate();
+
+      expect(errors.length).toBeGreaterThan(0);
+      const ageError = errors.find((e) => e.property === 'age');
+      expect(ageError).toBeDefined();
+      expect(ageError?.constraints).toHaveProperty('invalidAge');
+    });
+
+    it('should require parentEmail for minors', async () => {
+      const personData = {
+        age: 16,
+        email: 'jane@example.com',
+        firstName: 'Jane',
+        lastName: 'Smith',
+        // parentEmail missing
+      };
+
+      const person = Person.fromJSON(personData);
+      const errors = await person.validate();
+
+      expect(errors.length).toBeGreaterThan(0);
+      const parentEmailError = errors.find((e) => e.property === 'parentEmail');
+      expect(parentEmailError).toBeDefined();
+      expect(parentEmailError?.constraints).toHaveProperty('isNotEmpty');
+    });
+
+    it('should not require parentEmail for adults', async () => {
+      const personData = {
+        age: 25,
+        email: 'john@example.com',
+        firstName: 'John',
+        lastName: 'Doe',
+        // parentEmail not provided
+      };
+
+      const person = Person.fromJSON(personData);
+      const errors = await person.validate();
+
+      // Should not have parentEmail error
+      const parentEmailError = errors.find((e) => e.property === 'parentEmail');
+      expect(parentEmailError).toBeUndefined();
+    });
+  });
+
+  describe('JSON Serialization Tests', () => {
+    it('should exclude internalId from JSON output', () => {
+      const personData = {
+        age: 25,
+        email: 'john@example.com',
+        firstName: 'John',
+        internalId: 'secret-123',
+        isActive: true,
+        lastName: 'Doe',
+      };
+
+      const person = Person.fromJSON(personData);
+      const json = person.toJSON();
+
+      expect(json).not.toHaveProperty('internalId');
+      expect(json).toHaveProperty('firstName', 'John');
+      expect(json).toHaveProperty('lastName', 'Doe');
+      expect(json).toHaveProperty('email', 'john@example.com');
+      expect(json).toHaveProperty('age', 25);
+      expect(json).toHaveProperty('isActive', true);
+    });
+
+    it('should include phoneNumber for adults', () => {
+      const personData = {
+        age: 25,
+        email: 'john@example.com',
+        firstName: 'John',
+        lastName: 'Doe',
+        phoneNumber: '123-456-7890',
+      };
+
+      const person = Person.fromJSON(personData);
+      const json = person.toJSON();
+
+      expect(json).toHaveProperty('phoneNumber', '123-456-7890');
+    });
+
+    it('should exclude phoneNumber for minors', () => {
+      const personData = {
+        age: 16,
+        email: 'jane@example.com',
+        firstName: 'Jane',
+        lastName: 'Smith',
+        parentEmail: 'parent@example.com',
+        phoneNumber: '123-456-7890',
+      };
+
+      const person = Person.fromJSON(personData);
+      const json = person.toJSON();
+
+      expect(json).not.toHaveProperty('phoneNumber');
+      expect(json).toHaveProperty('firstName', 'Jane');
+      expect(json).toHaveProperty('parentEmail', 'parent@example.com');
+    });
+  });
+
+  describe('Field Type Tests', () => {
+    it('should handle boolean field correctly', async () => {
+      const personData = {
+        age: 25,
+        email: 'john@example.com',
+        firstName: 'John',
+        isActive: true,
+        lastName: 'Doe',
+      };
+
+      const person = Person.fromJSON(personData);
+      const errors = await person.validate();
+
+      expect(errors.length).toBe(0);
+      expect(person.isActive).toBe(true);
+    });
+
+    it('should handle HTML field correctly', async () => {
+      const personData = {
+        additionalInfo: '<p>This is <strong>HTML</strong> content</p>',
+        age: 25,
+        email: 'john@example.com',
+        firstName: 'John',
+        lastName: 'Doe',
+      };
+
+      const person = Person.fromJSON(personData);
+      const errors = await person.validate();
+
+      expect(errors.length).toBe(0);
+      expect(person.additionalInfo).toBe('<p>This is <strong>HTML</strong> content</p>');
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle missing required fields', async () => {
+      const personData = {
+        // Missing firstName, lastName, age
+        email: 'john@example.com',
+      };
+
+      const person = Person.fromJSON(personData);
+      const errors = await person.validate();
+
+      expect(errors.length).toBeGreaterThan(0);
+
+      const firstNameError = errors.find((e) => e.property === 'firstName');
+      const lastNameError = errors.find((e) => e.property === 'lastName');
+      const ageError = errors.find((e) => e.property === 'age');
+
+      expect(firstNameError).toBeDefined();
+      expect(lastNameError).toBeDefined();
+      expect(ageError).toBeDefined();
+    });
+
+    it('should handle boundary age values', async () => {
+      const personData = {
+        age: 18, // Boundary between minor and adult
+        email: 'john@example.com',
+        firstName: 'John',
+        lastName: 'Doe',
+      };
+
+      const person = Person.fromJSON(personData);
+      const errors = await person.validate();
+
+      expect(errors.length).toBe(0);
+
+      // At 18, parentEmail should not be required
+      const parentEmailError = errors.find((e) => e.property === 'parentEmail');
+      expect(parentEmailError).toBeUndefined();
+    });
+  });
+});

package/src/templates/src/Person.ts.template

@@ -0,0 +1,105 @@
+import { Field, Text, Email, Html, Boolean, Model, BaseModel, Uuid, Integer, SharedComposition } from "slingr-framework";
+import { Address } from "./Address";
+import { {{DATASOURCE_NAME}} } from "../dataSources/{{DATASOURCE_FILE}}";
+
+@Model({
+    docs: "Represents a person",
+    dataSource: {{DATASOURCE_NAME}}
+})
+export class Person extends BaseModel {
+    @Field({
+        required: true,
+        primaryKey: true,
+    })
+    @Uuid(
+        {
+            generated: true
+        }
+    )
+    id!: string;
+
+    @Field({
+        required: true,
+    })
+    @Text({
+        minLength: 2,
+        maxLength: 30,
+        regex: /^[a-zA-Z]+$/,
+        regexMessage: "firstName must contain only letters",
+    })
+    firstName!: string;
+
+    @Field({
+        required: true,
+    })
+    @Text({
+        minLength: 2,
+        maxLength: 30,
+        regex: /^[a-zA-Z]+$/,
+        regexMessage: "lastName must contain only letters",
+    })
+    lastName!: string;
+
+    @Field()
+    @Email()
+    email!: string;
+
+    @Field({
+        validation: (_: number, person: Person) => {
+            let errors = [];
+            if (person.age < 0 || person.age > 120) {
+                errors.push({
+                    constraint: "invalidAge",
+                    message: "Age must be between 0 and 120",
+                });
+            }
+            return errors;
+        },
+        required: true,
+    })
+    @Integer()
+    age!: number;
+
+
+    @Field({
+        required: (person: Person) => {
+            return (person.age < 18);
+        },
+    })
+    @Email()
+    parentEmail!: string;
+
+
+    @Field({
+        available: false, // This field should be excluded from JSON operations
+        docs: "Internal identifier not exposed in JSON"
+    })
+    @Text()
+    internalId!: string;
+
+    @Field({
+        required: false,
+        available: (person: Person) => {
+            return person.age >= 18;
+        },
+    })
+    @Text()
+    phoneNumber!: string;
+
+    @Field()
+    @Html()
+    additionalInfo!: string;
+
+    @Field({
+        required: false,
+    })
+    @Boolean()
+    isActive!: boolean;
+
+    @Field({
+        required: false
+    })
+    @SharedComposition({ elementType: () => Address })
+    address!: Address;
+
+}

package/src/templates/src/actions/index.ts.template

@@ -0,0 +1,12 @@
+/**
+ * Actions index file for {{APP_NAME}}
+ * This file exports all actions that should be available in the GraphQL schema
+ */
+
+// Import any custom actions here
+// Example:
+// export * from './userActions';
+// export * from './companyActions';
+
+// For now, we'll just export an empty object to make the file valid
+export {};

package/src/templates/src/index.ts

@@ -0,0 +1,66 @@
+import { app } from 'slingr-framework';
+
+async function main() {
+  // Configure the application
+  app.configure({
+    graphql: {
+      port: 4000,
+      host: 'localhost',
+      enableExplorer: true,
+    },
+  });
+
+  // Start the application
+  await app.run();
+
+  console.log('');
+  console.log('✅ Application is ready!');
+  console.log('📊 GraphQL Playground: http://localhost:4000/graphql');
+  console.log('');
+
+  // Test a sample query (if SDK is available)
+  console.log('🔍 Testing GraphQL SDK...');
+
+  try {
+    // Check if SDK exists before trying to import it
+    const fs = await import('fs');
+    const path = await import('path');
+    const sdkPath = path.resolve(__dirname, '../generated/gql/index.ts');
+
+    if (fs.existsSync(sdkPath)) {
+      // Use dynamic import with variable to avoid TypeScript compile-time resolution
+      const sdkModule = '../generated/gql/index';
+      const gql = await import(sdkModule);
+
+      if (gql.default && typeof gql.default.TestQuery === 'function') {
+        const result = await gql.default.TestQuery();
+        console.log('✅ GraphQL SDK is working! Test query result:', JSON.stringify(result, null, 2));
+        console.log('🚀 Your GraphQL API is ready to use with type-safe queries!');
+        console.log('💡 Import using: import gql from "@gql" (alias) or "../generated/gql"');
+      } else {
+        console.log('✅ GraphQL SDK loaded successfully!');
+        console.log('ℹ️  No test query available, but the SDK is ready for your custom operations.');
+        console.log('📝 Edit operations.graphql to add your GraphQL queries and mutations.');
+      }
+    } else {
+      console.log('ℹ️  GraphQL SDK not available yet.');
+      console.log('💡 Run the complete setup to generate schema and SDK:');
+      console.log('   npx slingr setup');
+    }
+  } catch (error: any) {
+    console.log('ℹ️  GraphQL SDK may need to be regenerated after recent changes.');
+    console.log('💡 Try regenerating the SDK:');
+    console.log('   npx slingr gql generate-schema');
+    console.log('   npx slingr gql generate-sdk');
+  }
+
+  console.log('');
+
+  console.log('');
+  console.log('Press Ctrl+C to stop');
+}
+
+main().catch(error => {
+  console.error('❌ Failed to start application:', error);
+  process.exit(1);
+});

package/src/templates/src/types/gql.d.ts.template

@@ -0,0 +1,18 @@
+/**
+ * Temporary type declaration for @gql module
+ * This file prevents TypeScript compilation errors when the GraphQL SDK hasn't been generated yet.
+ * It will be automatically replaced when you run: slingr gql generate-sdk
+ */
+
+declare module '@gql' {
+  // Placeholder interface for when SDK is not generated yet
+  interface PlaceholderGQL {
+    TestQuery?: () => Promise<any>;
+    [key: string]: any;
+  }
+  
+  const gql: PlaceholderGQL;
+  export default gql;
+}
+
+// This file can be safely deleted after running: slingr gql generate-sdk

package/src/templates/vscode/extensions.json

@@ -0,0 +1,3 @@
+{
+  "recommendations": ["github.copilot", "slingr.slingr"]
+}

package/src/templates/vscode/settings.json

@@ -0,0 +1,11 @@
+{
+  "editor.formatOnSave": true,
+  "editor.inlineSuggest.enabled": true,
+  "github.copilot.advanced": {},
+  "github.copilot.enable": {
+    "*": true,
+    "markdown": true,
+    "plaintext": true
+  },
+  "typescript.preferences.importModuleSpecifier": "relative"
+}