parse-stack-next 4.5.0

data/bin/parse-console

@@ -0,0 +1,136 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'json'
+require 'open-uri'
+require 'active_support'
+require 'active_support/core_ext'
+
+DEFAULT_CONFIG_FILE = 'config.json'
+DEFAULT_CONFIG_CONTENTS = {
+  "apps": [{
+    "serverURL": "http://localhost:1337/parse",
+    "appId": "myAppId",
+    "masterKey": "myMasterKey",
+    "restAPIKey": "myRestAPIKey",
+    "javascriptKey": "myJavascriptKey",
+    "appName": "Parse Server App"
+  }]
+}.freeze
+
+opts = { verbose: false, pry: false }
+opt_parser = OptionParser.new do |o|
+
+  o.banner =   "Usage: #{File.basename($0)} [options] SERVER_URL"
+  o.separator  ""
+  o.separator  "Example:"
+  o.separator  "#{File.basename($0)} -a APP_ID -m MASTER_KEY https://your-parse-server-url"
+  o.separator  "#{File.basename($0)} -c ./config.json"
+  o.separator  ""
+  o.separator  "If you use the -m option, parse-console will automatically"
+  o.separator  "import your schema as ruby models."
+  o.separator  ""
+  o.separator  "Options"
+  o.on('-a APP_ID', '--appId APP_ID', 'Parse App ID (required)') { |a| opts[:app_id] = a }
+  o.on('-k REST_API_KEY', '--restAPIKey REST_API_KEY', 'Parse REST API Key') { |a| opts[:api_key] = a }
+  o.on('-m MASTER_KEY', '--masterKey MASTER_KEY', 'Parse Master Key') { |a| opts[:master_key] = a }
+  o.on('-s SERVER_URL', '--serverURL SERVER_URL', 'The Parse server url.', 'Defaults to http://localhost:1337/parse') { |a| opts[:server_url] = a }
+  o.on('-v','--[no-]verbose', 'Run verbosely') { |v| opts[:verbose] ||= v }
+  o.on('--pry', 'Use Pry instead of IRB') { |v| opts[:pry] = v }
+  o.on('--version', 'Parse Stack version') do |v|
+    require 'parse/stack/version'
+    puts "Parse Stack : #{Parse::Stack::VERSION}"
+    exit 1
+  end
+  o.on('--config-sample', "Create a sample config file to use. See --config.") do
+    contents = JSON.pretty_generate(DEFAULT_CONFIG_CONTENTS)
+    File.open(DEFAULT_CONFIG_FILE, 'w') { |f| f.write(contents) }
+    puts "Created #{DEFAULT_CONFIG_FILE} : \n"
+    puts contents
+    puts "Edit #{DEFAULT_CONFIG_FILE} with your information and run: \n"
+    puts "\n\tparse-console -c ./#{DEFAULT_CONFIG_FILE}\n\n"
+    exit 1
+  end
+  o.on('-c','--config CONFIG_JSON', "Load config from a parse-dashboard.json compatible file.") do |filepath|
+    unless File.exist?(filepath)
+      $stderr.puts "File #{filepath} does not exist."
+      exit 1
+    end
+
+    begin
+      puts "Loading config: #{filepath}"
+      file = File.read(filepath)
+      config = JSON.parse file
+      app = config["apps"].is_a?(Array) ?  config["apps"].first : config["apps"]
+      app = config if app.nil? # uses parse-server config.json
+      opts[:server_url] ||= app["serverURL"]
+      opts[:app_id] ||= app["appId"]
+      opts[:api_key] ||= app["restAPIKey"]
+      opts[:master_key] ||= app["masterKey"]
+    rescue Exception => e
+      $stderr.puts "Error: Incompatible JSON format for #{filepath} (#{e})"
+      exit 1
+    end
+
+  end
+  o.on('--url URL', 'Load the env config from a url.') do |url|
+    begin
+      puts "Loading config: #{url}"
+      json = JSON.load open(url)
+      raise "Contents not a JSON hash." unless json.is_a?(Hash)
+      json.each { |k,v| ENV[k.upcase] = v }
+      opts[:server_url] ||= ENV['PARSE_SERVER_URL']
+      opts[:app_id]     ||= ENV['PARSE_SERVER_APPLICATION_ID'] || ENV['PARSE_APP_ID']
+      opts[:api_key]    ||= ENV['PARSE_SERVER_REST_API_KEY']   || ENV['PARSE_API_KEY']
+      opts[:master_key] ||= ENV['PARSE_SERVER_MASTER_KEY']     || ENV['PARSE_MASTER_KEY']
+    rescue Exception => e
+      $stderr.puts "Error: Invalid JSON format for #{url} (#{e})"
+      exit 1
+    end
+  end
+end
+opt_parser.parse!
+
+opts[:server_url] ||= ARGV.shift || 'http://localhost:1337/parse'
+
+if opts[:app_id].nil?
+  $stderr.puts "Error: Option --app_id missing\n"
+  $stderr.puts opt_parser
+  exit 1
+end
+
+if opts[:api_key].nil? && opts[:master_key].nil?
+  $stderr.puts "Error: You must supply either --api_key (REST API Key) or --master_key (Parse Master key).\n"
+  $stderr.puts opt_parser
+  exit 1
+end
+
+# lazy loading
+require "parse/stack"
+Parse.setup server_url: opts[:server_url],
+            app_id: opts[:app_id],
+            api_key: opts[:api_key],
+            master_key: opts[:master_key]
+Parse.logging = true if opts[:verbose]
+puts "Server : #{Parse.client.server_url}"
+puts "App Id : #{Parse.client.app_id}"
+puts "Master : #{Parse.client.master_key.present?}"
+
+if Parse.client.master_key.present?
+  puts "Schema : imported"
+  Parse.auto_generate_models!.each do |model|
+    puts "Generated #{model}" if opts[:verbose]
+  end
+else
+  puts "Schema : skipped (requires master key)"
+end
+# Create shortnames
+Parse.use_shortnames!
+
+if opts[:pry]
+  require "pry"
+  Pry.start
+else
+  require "irb"
+  IRB.start
+end

data/bin/server

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "parse/stack"
+
+require "rack"
+require "puma"
+
+# For Rack v3 compatibility, Rack::Server has been moved to rackup gem
+# Using a simple Puma server directly instead
+puts "Starting Parse::Webhooks server on port 9292..."
+puts "Visit http://localhost:9292"
+
+app = Parse::Webhooks
+server = Puma::Server.new(app)
+server.add_tcp_listener "0.0.0.0", 9292
+server.run

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/config/parse-config.json

@@ -0,0 +1,12 @@
+{
+  "appId": "myAppId",
+  "masterKey": "myMasterKey",
+  "restAPIKey": "test-rest-key",
+  "databaseURI": "mongodb://admin:password@mongo:27017/parse?authSource=admin",
+  "serverURL": "http://localhost:1337/parse",
+  "mountPath": "/parse",
+  "cloud": "/parse-server/cloud/main.js",
+  "logLevel": "info",
+  "allowClientClassCreation": true,
+  "allowCustomObjectId": true
+}

data/docs/TEST_SERVER.md

@@ -0,0 +1,271 @@
+# Parse Stack Test Server Setup
+
+This document explains how to set up a local Parse Server for testing the parse-stack Ruby SDK.
+
+## Quick Start
+
+### Option 1: Using Make (Recommended)
+
+```bash
+# Start the test server
+make test-server-start
+
+# Test the connection
+make test-connection
+
+# Run integration tests
+make test-integration
+
+# Stop the test server
+make test-server-stop
+```
+
+### Option 2: Docker Compose
+
+1. **Start the test server:**
+   ```bash
+   docker-compose -f docker-compose.test.yml up -d
+   ```
+
+2. **Test the connection:**
+   ```bash
+   ruby test_server_connection.rb
+   ```
+
+3. **Run integration tests:**
+   ```bash
+   PARSE_TEST_USE_DOCKER=true bundle exec rake test
+   ```
+
+4. **Stop the test server:**
+   ```bash
+   docker-compose -f docker-compose.test.yml down
+   ```
+
+### Option 3: Use Your Own Parse Server
+
+Set environment variables to point to your Parse Server:
+
+```bash
+export PARSE_TEST_SERVER_URL="http://your-server:1337/parse"
+export PARSE_TEST_APP_ID="your-app-id"
+export PARSE_TEST_API_KEY="your-rest-key"  
+export PARSE_TEST_MASTER_KEY="your-master-key"
+```
+
+## Services Included
+
+The Docker Compose setup provides:
+
+- **MongoDB** (port 27017): Database backend
+- **Parse Server** (port 1337): Main API server with custom startup script
+- **Parse Dashboard** (port 4040): Web interface for data management
+
+## Technical Implementation
+
+### Custom Parse Server Image
+
+The setup uses a custom Docker image built on top of `parseplatform/parse-server:8.2.3` that includes:
+
+- **Custom startup script** (`scripts/start-parse.sh`) that sets the `PARSE_SERVER_MASTER_KEY_IPS` environment variable
+- **IP restriction bypass** allowing requests from any IP address (`0.0.0.0/0,::/0`)
+- **Automatic environment variable setup** for proper master key authentication
+
+### Master Key Authentication
+
+The setup resolves Parse Server's IP restriction for master key usage by:
+
+1. Using a custom Docker image with an embedded startup script
+2. Setting `PARSE_SERVER_MASTER_KEY_IPS=0.0.0.0/0,::/0` to allow all IP addresses
+3. This enables schema operations and full master key functionality for testing
+
+### File Structure
+
+```
+parse-stack-next/
+├── scripts/
+│   ├── docker/
+│   │   ├── docker-compose.test.yml # Main Docker Compose configuration
+│   │   └── Dockerfile.parse       # Custom Parse Server image
+│   ├── start-parse.sh             # Startup script with environment setup
+│   └── test_server_connection.rb  # Connection test script
+├── config/
+│   └── parse-config.json    # Parse Server configuration (unused)
+├── test/
+│   ├── cloud/
+│   │   └── main.js         # Cloud Code for testing
+│   └── support/
+│       ├── test_server.rb   # Ruby test helper utilities
+│       └── docker_helper.rb # Docker container management
+└── .env.test              # Environment variable defaults
+```
+
+## Test Configuration
+
+### Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `PARSE_TEST_SERVER_URL` | `http://localhost:1337/parse` | Parse Server URL |
+| `PARSE_TEST_APP_ID` | `myAppId` | Application ID |
+| `PARSE_TEST_API_KEY` | `test-rest-key` | REST API Key |
+| `PARSE_TEST_MASTER_KEY` | `myMasterKey` | Master Key |
+| `PARSE_TEST_USE_DOCKER` | `false` | Auto-manage Docker containers |
+| `PARSE_TEST_AUTO_START` | `false` | Start containers automatically |
+| `PARSE_TEST_AUTO_STOP` | `false` | Stop containers on exit |
+
+### Using `.env.test`
+
+Copy and customize the test environment file:
+
+```bash
+cp .env.test .env.test.local
+# Edit .env.test.local with your settings
+```
+
+## Writing Integration Tests
+
+### Basic Setup
+
+```ruby
+require_relative 'test_helper_integration'
+
+class MyIntegrationTest < Minitest::Test
+  include ParseStackIntegrationTest
+  
+  def test_user_creation
+    with_parse_server do
+      user = create_test_user(username: 'testuser')
+      assert user.id.present?
+      assert_equal 'testuser', user.username
+    end
+  end
+end
+```
+
+### Test Helpers Available
+
+- `with_parse_server { }` - Skip test if server unavailable
+- `create_test_user(attributes)` - Create and track test user
+- `create_test_object(class_name, attributes)` - Create and track test object
+- `reset_database!` - Clear all non-system data
+- `@test_context.track(object)` - Track object for cleanup
+
+### Manual Server Management
+
+```ruby
+# In your tests or console
+require 'test/support/docker_helper'
+
+# Start containers
+Parse::Test::DockerHelper.start!
+
+# Check if running
+Parse::Test::DockerHelper.running?
+
+# View logs
+puts Parse::Test::DockerHelper.logs
+
+# Stop containers
+Parse::Test::DockerHelper.stop!
+```
+
+## Dashboard Access
+
+When using Docker Compose, you can access the Parse Dashboard at:
+- URL: http://localhost:4040
+- Username: `admin`
+- Password: `admin`
+
+## Cloud Code Testing
+
+Sample cloud functions are provided in `test/cloud/main.js`:
+
+```ruby
+# Test cloud functions
+result = Parse::CloudFunction.call('hello', name: 'World')
+assert_equal 'Hello World!', result
+```
+
+## Troubleshooting
+
+### Docker Issues
+
+```bash
+# Check container status
+docker-compose -f docker-compose.test.yml ps
+
+# View Parse Server logs
+docker logs parse-stack-test-server
+
+# Reset everything
+docker-compose -f docker-compose.test.yml down -v
+docker-compose -f docker-compose.test.yml up -d
+```
+
+### Master Key Authentication Issues
+
+If you see `Request using master key rejected as the request IP address ... is not set in Parse Server option 'masterKeyIps'`:
+
+1. **Verify the custom image is built**: 
+   ```bash
+   docker-compose -f docker-compose.test.yml build parse
+   ```
+
+2. **Check startup script execution**:
+   ```bash
+   docker logs parse-stack-test-server | grep "PARSE_SERVER_MASTER_KEY_IPS"
+   ```
+   Should show: `PARSE_SERVER_MASTER_KEY_IPS: 0.0.0.0/0,::/0`
+
+3. **Test master key directly**:
+   ```bash
+   curl -X GET \
+     -H "X-Parse-Application-Id: myAppId" \
+     -H "X-Parse-Master-Key: myMasterKey" \
+     http://localhost:1337/parse/schemas
+   ```
+
+### Connection Issues
+
+```ruby
+# Test connectivity in console
+require 'test/support/test_server'
+Parse::Test::ServerHelper.setup
+Parse::Test::ServerHelper.server_available?
+```
+
+### Port Conflicts
+
+If ports 1337, 4040, or 27017 are in use, modify `docker-compose.test.yml`:
+
+```yaml
+services:
+  parse:
+    ports:
+      - "1338:1337"  # Use port 1338 instead
+```
+
+Then update your environment variables accordingly.
+
+## Production vs Test Differences
+
+The test server configuration includes:
+- Relaxed security settings for testing
+- Auto-creation of classes
+- Verbose logging
+- Sample cloud code
+
+**Never use these settings in production!**
+
+## Status
+
+✅ **Working Setup**: This test server configuration has been verified to work with:
+- Parse Server 8.2.3
+- MongoDB 5.0  
+- Master key authentication for schema operations
+- Basic CRUD operations via REST API
+- Ruby Parse Stack SDK connection
+- Cloud Code execution
+
+The setup successfully resolves Parse Server's IP restriction issues that typically prevent master key usage in Docker environments.

data/docs/_config.yml

@@ -0,0 +1 @@
+theme: jekyll-theme-midnight