From f316d673d06aa85556f55573ddc7040b85765504 Mon Sep 17 00:00:00 2001 From: zouantchaw <44246692+zouantchaw@users.noreply.github.com> Date: Thu, 26 Feb 2026 10:37:39 -0500 Subject: [PATCH 01/21] chore(skills): bootstrap repo-local skills under .agents/skills --- .agents/skills/api-authentication/SKILL.md | 343 +++++++++ .agents/skills/api-contract-testing/SKILL.md | 624 +++++++++++++++++ .../skills/api-security-hardening/SKILL.md | 659 ++++++++++++++++++ .../database-migration-management/SKILL.md | 384 ++++++++++ .agents/skills/find-skills/SKILL.md | 133 ++++ .agents/skills/gcp-cloud-run/SKILL.md | 292 ++++++++ 6 files changed, 2435 insertions(+) create mode 100644 .agents/skills/api-authentication/SKILL.md create mode 100644 .agents/skills/api-contract-testing/SKILL.md create mode 100644 .agents/skills/api-security-hardening/SKILL.md create mode 100644 .agents/skills/database-migration-management/SKILL.md create mode 100644 .agents/skills/find-skills/SKILL.md create mode 100644 .agents/skills/gcp-cloud-run/SKILL.md diff --git a/.agents/skills/api-authentication/SKILL.md b/.agents/skills/api-authentication/SKILL.md new file mode 100644 index 00000000..d616f405 --- /dev/null +++ b/.agents/skills/api-authentication/SKILL.md @@ -0,0 +1,343 @@ +--- +name: api-authentication +description: Implement secure API authentication with JWT, OAuth 2.0, API keys, and session management. Use when securing APIs, managing tokens, or implementing user authentication flows. +--- + +# API Authentication + +## Overview + +Implement comprehensive authentication strategies for APIs including JWT tokens, OAuth 2.0, API keys, and session management with proper security practices. + +## When to Use + +- Securing API endpoints +- Implementing user login/logout flows +- Managing access tokens and refresh tokens +- Integrating OAuth 2.0 providers +- Protecting sensitive data +- Implementing API key authentication + +## Instructions + +### 1. **JWT Authentication** + +```javascript +// Node.js JWT Implementation +const express = require('express'); +const jwt = require('jsonwebtoken'); +const bcrypt = require('bcrypt'); + +const app = express(); +const SECRET_KEY = process.env.JWT_SECRET || 'your-secret-key'; +const REFRESH_SECRET = process.env.REFRESH_SECRET || 'your-refresh-secret'; + +// User login endpoint +app.post('/api/auth/login', async (req, res) => { + try { + const { email, password } = req.body; + + // Find user in database + const user = await User.findOne({ email }); + if (!user) { + return res.status(401).json({ error: 'Invalid credentials' }); + } + + // Verify password + const isValid = await bcrypt.compare(password, user.password); + if (!isValid) { + return res.status(401).json({ error: 'Invalid credentials' }); + } + + // Generate tokens + const accessToken = jwt.sign( + { userId: user.id, email: user.email, role: user.role }, + SECRET_KEY, + { expiresIn: '15m' } + ); + + const refreshToken = jwt.sign( + { userId: user.id }, + REFRESH_SECRET, + { expiresIn: '7d' } + ); + + // Store refresh token in database + await RefreshToken.create({ token: refreshToken, userId: user.id }); + + res.json({ + accessToken, + refreshToken, + expiresIn: 900, + user: { id: user.id, email: user.email, role: user.role } + }); + } catch (error) { + res.status(500).json({ error: 'Authentication failed' }); + } +}); + +// Refresh token endpoint +app.post('/api/auth/refresh', (req, res) => { + const { refreshToken } = req.body; + + if (!refreshToken) { + return res.status(401).json({ error: 'Refresh token required' }); + } + + try { + const decoded = jwt.verify(refreshToken, REFRESH_SECRET); + + // Verify token exists in database + const storedToken = await RefreshToken.findOne({ + token: refreshToken, + userId: decoded.userId + }); + + if (!storedToken) { + return res.status(401).json({ error: 'Invalid refresh token' }); + } + + // Generate new access token + const newAccessToken = jwt.sign( + { userId: decoded.userId }, + SECRET_KEY, + { expiresIn: '15m' } + ); + + res.json({ accessToken: newAccessToken, expiresIn: 900 }); + } catch (error) { + res.status(401).json({ error: 'Invalid refresh token' }); + } +}); + +// Middleware to verify JWT +const verifyToken = (req, res, next) => { + const authHeader = req.headers['authorization']; + const token = authHeader && authHeader.split(' ')[1]; // Bearer token + + if (!token) { + return res.status(401).json({ error: 'Access token required' }); + } + + try { + const decoded = jwt.verify(token, SECRET_KEY); + req.user = decoded; + next(); + } catch (error) { + if (error.name === 'TokenExpiredError') { + return res.status(401).json({ error: 'Token expired', code: 'TOKEN_EXPIRED' }); + } + res.status(403).json({ error: 'Invalid token' }); + } +}; + +// Protected endpoint +app.get('/api/profile', verifyToken, (req, res) => { + res.json({ user: req.user }); +}); + +// Logout endpoint +app.post('/api/auth/logout', verifyToken, async (req, res) => { + try { + await RefreshToken.deleteOne({ userId: req.user.userId }); + res.json({ message: 'Logged out successfully' }); + } catch (error) { + res.status(500).json({ error: 'Logout failed' }); + } +}); +``` + +### 2. **OAuth 2.0 Implementation** + +```javascript +const passport = require('passport'); +const GoogleStrategy = require('passport-google-oauth20').Strategy; + +passport.use(new GoogleStrategy( + { + clientID: process.env.GOOGLE_CLIENT_ID, + clientSecret: process.env.GOOGLE_CLIENT_SECRET, + callbackURL: '/api/auth/google/callback' + }, + async (accessToken, refreshToken, profile, done) => { + try { + let user = await User.findOne({ googleId: profile.id }); + + if (!user) { + user = await User.create({ + googleId: profile.id, + email: profile.emails[0].value, + firstName: profile.name.givenName, + lastName: profile.name.familyName + }); + } + + return done(null, user); + } catch (error) { + return done(error); + } + } +)); + +// OAuth routes +app.get('/api/auth/google', + passport.authenticate('google', { scope: ['profile', 'email'] }) +); + +app.get('/api/auth/google/callback', + passport.authenticate('google', { failureRedirect: '/login' }), + (req, res) => { + const token = jwt.sign( + { userId: req.user.id, email: req.user.email }, + SECRET_KEY, + { expiresIn: '7d' } + ); + res.redirect(`/dashboard?token=${token}`); + } +); +``` + +### 3. **API Key Authentication** + +```javascript +// API Key middleware +const verifyApiKey = (req, res, next) => { + const apiKey = req.headers['x-api-key']; + + if (!apiKey) { + return res.status(401).json({ error: 'API key required' }); + } + + try { + // Verify API key format and existence + const keyHash = crypto.createHash('sha256').update(apiKey).digest('hex'); + const apiKeyRecord = await ApiKey.findOne({ key_hash: keyHash, active: true }); + + if (!apiKeyRecord) { + return res.status(401).json({ error: 'Invalid API key' }); + } + + req.apiKey = apiKeyRecord; + next(); + } catch (error) { + res.status(500).json({ error: 'Authentication failed' }); + } +}; + +// Generate API key endpoint +app.post('/api/apikeys/generate', verifyToken, async (req, res) => { + try { + const apiKey = crypto.randomBytes(32).toString('hex'); + const keyHash = crypto.createHash('sha256').update(apiKey).digest('hex'); + + const record = await ApiKey.create({ + userId: req.user.userId, + key_hash: keyHash, + name: req.body.name, + active: true + }); + + res.json({ apiKey, message: 'Save this key securely' }); + } catch (error) { + res.status(500).json({ error: 'Failed to generate API key' }); + } +}); + +// Protected endpoint with API key +app.get('/api/data', verifyApiKey, (req, res) => { + res.json({ data: 'sensitive data for API key holder' }); +}); +``` + +### 4. **Python Authentication Implementation** + +```python +from flask import Flask, request, jsonify +from flask_jwt_extended import JWTManager, create_access_token, jwt_required +from werkzeug.security import generate_password_hash, check_password_hash +from functools import wraps + +app = Flask(__name__) +app.config['JWT_SECRET_KEY'] = 'secret-key' +jwt = JWTManager(app) + +@app.route('/api/auth/login', methods=['POST']) +def login(): + data = request.get_json() + user = User.query.filter_by(email=data['email']).first() + + if not user or not check_password_hash(user.password, data['password']): + return jsonify({'error': 'Invalid credentials'}), 401 + + access_token = create_access_token( + identity=user.id, + additional_claims={'email': user.email, 'role': user.role} + ) + + return jsonify({ + 'accessToken': access_token, + 'user': {'id': user.id, 'email': user.email} + }), 200 + +@app.route('/api/protected', methods=['GET']) +@jwt_required() +def protected(): + from flask_jwt_extended import get_jwt_identity + user_id = get_jwt_identity() + return jsonify({'userId': user_id}), 200 + +def require_role(role): + def decorator(fn): + @wraps(fn) + @jwt_required() + def wrapper(*args, **kwargs): + from flask_jwt_extended import get_jwt + claims = get_jwt() + if claims.get('role') != role: + return jsonify({'error': 'Forbidden'}), 403 + return fn(*args, **kwargs) + return wrapper + return decorator + +@app.route('/api/admin', methods=['GET']) +@require_role('admin') +def admin_endpoint(): + return jsonify({'message': 'Admin data'}), 200 +``` + +## Best Practices + +### ✅ DO +- Use HTTPS for all authentication +- Store tokens securely (HttpOnly cookies) +- Implement token refresh mechanism +- Set appropriate token expiration times +- Hash and salt passwords +- Use strong secret keys +- Validate tokens on every request +- Implement rate limiting on auth endpoints +- Log authentication attempts +- Rotate secrets regularly + +### ❌ DON'T +- Store passwords in plain text +- Send tokens in URL parameters +- Use weak secret keys +- Store sensitive data in JWT payload +- Ignore token expiration +- Disable HTTPS in production +- Log sensitive tokens +- Reuse API keys across services +- Store credentials in code + +## Security Headers + +```javascript +app.use((req, res, next) => { + res.setHeader('X-Content-Type-Options', 'nosniff'); + res.setHeader('X-Frame-Options', 'DENY'); + res.setHeader('X-XSS-Protection', '1; mode=block'); + res.setHeader('Strict-Transport-Security', 'max-age=31536000; includeSubDomains'); + next(); +}); +``` diff --git a/.agents/skills/api-contract-testing/SKILL.md b/.agents/skills/api-contract-testing/SKILL.md new file mode 100644 index 00000000..ba79cd94 --- /dev/null +++ b/.agents/skills/api-contract-testing/SKILL.md @@ -0,0 +1,624 @@ +--- +name: api-contract-testing +description: Verify API contracts between services to ensure compatibility and prevent breaking changes. Use for contract testing, Pact, API contract validation, schema validation, and consumer-driven contracts. +--- + +# API Contract Testing + +## Overview + +Contract testing verifies that APIs honor their contracts between consumers and providers. It ensures that service changes don't break dependent consumers without requiring full integration tests. Contract tests validate request/response formats, data types, and API behavior independently. + +## When to Use + +- Testing microservices communication +- Preventing breaking API changes +- Validating API versioning +- Testing consumer-provider contracts +- Ensuring backward compatibility +- Validating OpenAPI/Swagger specifications +- Testing third-party API integrations +- Catching contract violations in CI + +## Key Concepts + +- **Consumer**: Service that calls an API +- **Provider**: Service that exposes the API +- **Contract**: Agreement on API request/response format +- **Pact**: Consumer-defined expectations +- **Schema**: Structure definition (OpenAPI, JSON Schema) +- **Stub**: Generated mock from contract +- **Broker**: Central repository for contracts + +## Instructions + +### 1. **Pact for Consumer-Driven Contracts** + +#### Consumer Test (Jest/Pact) +```typescript +// tests/pact/user-service.pact.test.ts +import { PactV3, MatchersV3 } from '@pact-foundation/pact'; +import { UserService } from '../../src/services/UserService'; + +const { like, eachLike, iso8601DateTimeWithMillis } = MatchersV3; + +const provider = new PactV3({ + consumer: 'OrderService', + provider: 'UserService', + port: 1234, + dir: './pacts', +}); + +describe('User Service Contract', () => { + const userService = new UserService('http://localhost:1234'); + + describe('GET /users/:id', () => { + test('returns user when found', async () => { + await provider + .given('user with ID 123 exists') + .uponReceiving('a request for user 123') + .withRequest({ + method: 'GET', + path: '/users/123', + headers: { + Authorization: like('Bearer token'), + }, + }) + .willRespondWith({ + status: 200, + headers: { + 'Content-Type': 'application/json', + }, + body: { + id: like('123'), + email: like('user@example.com'), + name: like('John Doe'), + age: like(30), + createdAt: iso8601DateTimeWithMillis('2024-01-01T00:00:00.000Z'), + role: like('user'), + }, + }) + .executeTest(async (mockServer) => { + const user = await userService.getUser('123'); + + expect(user.id).toBe('123'); + expect(user.email).toBeDefined(); + expect(user.name).toBeDefined(); + }); + }); + + test('returns 404 when user not found', async () => { + await provider + .given('user with ID 999 does not exist') + .uponReceiving('a request for non-existent user') + .withRequest({ + method: 'GET', + path: '/users/999', + }) + .willRespondWith({ + status: 404, + headers: { + 'Content-Type': 'application/json', + }, + body: { + error: like('User not found'), + code: like('USER_NOT_FOUND'), + }, + }) + .executeTest(async (mockServer) => { + await expect(userService.getUser('999')).rejects.toThrow( + 'User not found' + ); + }); + }); + }); + + describe('POST /users', () => { + test('creates new user', async () => { + await provider + .given('user does not exist') + .uponReceiving('a request to create user') + .withRequest({ + method: 'POST', + path: '/users', + headers: { + 'Content-Type': 'application/json', + }, + body: { + email: like('newuser@example.com'), + name: like('New User'), + age: like(25), + }, + }) + .willRespondWith({ + status: 201, + headers: { + 'Content-Type': 'application/json', + }, + body: { + id: like('new-123'), + email: like('newuser@example.com'), + name: like('New User'), + age: like(25), + createdAt: iso8601DateTimeWithMillis(), + role: 'user', + }, + }) + .executeTest(async (mockServer) => { + const user = await userService.createUser({ + email: 'newuser@example.com', + name: 'New User', + age: 25, + }); + + expect(user.id).toBeDefined(); + expect(user.email).toBe('newuser@example.com'); + }); + }); + }); + + describe('GET /users/:id/orders', () => { + test('returns user orders', async () => { + await provider + .given('user 123 has orders') + .uponReceiving('a request for user orders') + .withRequest({ + method: 'GET', + path: '/users/123/orders', + query: { + limit: '10', + offset: '0', + }, + }) + .willRespondWith({ + status: 200, + body: { + orders: eachLike({ + id: like('order-1'), + total: like(99.99), + status: like('completed'), + createdAt: iso8601DateTimeWithMillis(), + }), + total: like(5), + hasMore: like(false), + }, + }) + .executeTest(async (mockServer) => { + const response = await userService.getUserOrders('123', { + limit: 10, + offset: 0, + }); + + expect(response.orders).toBeDefined(); + expect(Array.isArray(response.orders)).toBe(true); + expect(response.total).toBeDefined(); + }); + }); + }); +}); +``` + +#### Provider Test (Verify Contract) +```typescript +// tests/pact/user-service.provider.test.ts +import { Verifier } from '@pact-foundation/pact'; +import path from 'path'; +import { app } from '../../src/app'; +import { setupTestDB, teardownTestDB } from '../helpers/db'; + +describe('Pact Provider Verification', () => { + let server; + + beforeAll(async () => { + await setupTestDB(); + server = app.listen(3001); + }); + + afterAll(async () => { + await teardownTestDB(); + server.close(); + }); + + test('validates the expectations of OrderService', () => { + return new Verifier({ + provider: 'UserService', + providerBaseUrl: 'http://localhost:3001', + pactUrls: [ + path.resolve(__dirname, '../../pacts/orderservice-userservice.json'), + ], + // Provider state setup + stateHandlers: { + 'user with ID 123 exists': async () => { + await createTestUser({ id: '123', name: 'John Doe' }); + }, + 'user with ID 999 does not exist': async () => { + await deleteUser('999'); + }, + 'user 123 has orders': async () => { + await createTestUser({ id: '123' }); + await createTestOrder({ userId: '123' }); + }, + }, + }) + .verifyProvider() + .then((output) => { + console.log('Pact Verification Complete!'); + }); + }); +}); +``` + +### 2. **OpenAPI Schema Validation** + +```typescript +// tests/contract/openapi.test.ts +import request from 'supertest'; +import { app } from '../../src/app'; +import OpenAPIValidator from 'express-openapi-validator'; +import fs from 'fs'; +import yaml from 'js-yaml'; + +describe('OpenAPI Contract Validation', () => { + let validator; + + beforeAll(() => { + const spec = yaml.load( + fs.readFileSync('./openapi.yaml', 'utf8') + ); + + validator = OpenAPIValidator.middleware({ + apiSpec: spec, + validateRequests: true, + validateResponses: true, + }); + }); + + test('GET /users/:id matches schema', async () => { + const response = await request(app) + .get('/users/123') + .expect(200); + + // Validate against OpenAPI schema + expect(response.body).toMatchObject({ + id: expect.any(String), + email: expect.stringMatching(/^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$/), + name: expect.any(String), + age: expect.any(Number), + createdAt: expect.stringMatching(/^\d{4}-\d{2}-\d{2}T/), + }); + }); + + test('POST /users validates request body', async () => { + const invalidUser = { + email: 'invalid-email', // Should fail validation + name: 'Test', + }; + + await request(app) + .post('/users') + .send(invalidUser) + .expect(400); + }); +}); +``` + +### 3. **JSON Schema Validation** + +```python +# tests/contract/test_schema_validation.py +import pytest +import jsonschema +from jsonschema import validate +import json + +# Define schemas +USER_SCHEMA = { + "type": "object", + "required": ["id", "email", "name"], + "properties": { + "id": {"type": "string"}, + "email": {"type": "string", "format": "email"}, + "name": {"type": "string"}, + "age": {"type": "integer", "minimum": 0, "maximum": 150}, + "role": {"type": "string", "enum": ["user", "admin"]}, + "createdAt": {"type": "string", "format": "date-time"}, + }, + "additionalProperties": False +} + +ORDER_SCHEMA = { + "type": "object", + "required": ["id", "userId", "total", "status"], + "properties": { + "id": {"type": "string"}, + "userId": {"type": "string"}, + "total": {"type": "number", "minimum": 0}, + "status": { + "type": "string", + "enum": ["pending", "paid", "shipped", "delivered", "cancelled"] + }, + "items": { + "type": "array", + "items": { + "type": "object", + "required": ["productId", "quantity", "price"], + "properties": { + "productId": {"type": "string"}, + "quantity": {"type": "integer", "minimum": 1}, + "price": {"type": "number", "minimum": 0}, + } + } + } + } +} + +class TestAPIContracts: + def test_get_user_response_schema(self, api_client): + """Validate user endpoint response against schema.""" + response = api_client.get('/api/users/123') + + assert response.status_code == 200 + data = response.json() + + # Validate against schema + validate(instance=data, schema=USER_SCHEMA) + + def test_create_user_request_schema(self, api_client): + """Validate create user request body.""" + valid_user = { + "email": "test@example.com", + "name": "Test User", + "age": 30, + } + + response = api_client.post('/api/users', json=valid_user) + assert response.status_code == 201 + + # Response should also match schema + validate(instance=response.json(), schema=USER_SCHEMA) + + def test_invalid_request_rejected(self, api_client): + """Invalid requests should be rejected.""" + invalid_user = { + "email": "not-an-email", + "age": -5, # Invalid age + } + + response = api_client.post('/api/users', json=invalid_user) + assert response.status_code == 400 + + def test_order_response_schema(self, api_client): + """Validate order endpoint response.""" + response = api_client.get('/api/orders/order-123') + + assert response.status_code == 200 + validate(instance=response.json(), schema=ORDER_SCHEMA) + + def test_order_items_array_validation(self, api_client): + """Validate nested array schema.""" + order_data = { + "userId": "user-123", + "items": [ + {"productId": "prod-1", "quantity": 2, "price": 29.99}, + {"productId": "prod-2", "quantity": 1, "price": 49.99}, + ] + } + + response = api_client.post('/api/orders', json=order_data) + assert response.status_code == 201 + + result = response.json() + validate(instance=result, schema=ORDER_SCHEMA) +``` + +### 4. **REST Assured for Java** + +```java +// ContractTest.java +import io.restassured.RestAssured; +import io.restassured.module.jsv.JsonSchemaValidator; +import org.junit.jupiter.api.Test; +import static io.restassured.RestAssured.*; +import static org.hamcrest.Matchers.*; + +public class UserAPIContractTest { + + @Test + public void getUserShouldMatchSchema() { + given() + .pathParam("id", "123") + .when() + .get("/api/users/{id}") + .then() + .statusCode(200) + .body(JsonSchemaValidator.matchesJsonSchemaInClasspath("schemas/user-schema.json")) + .body("id", notNullValue()) + .body("email", matchesPattern("^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$")) + .body("age", greaterThanOrEqualTo(0)); + } + + @Test + public void createUserShouldValidateRequest() { + String userJson = """ + { + "email": "test@example.com", + "name": "Test User", + "age": 30 + } + """; + + given() + .contentType("application/json") + .body(userJson) + .when() + .post("/api/users") + .then() + .statusCode(201) + .body("id", notNullValue()) + .body("email", equalTo("test@example.com")) + .body("createdAt", matchesPattern("\\d{4}-\\d{2}-\\d{2}T.*")); + } + + @Test + public void getUserOrdersShouldReturnArray() { + given() + .pathParam("id", "123") + .queryParam("limit", 10) + .when() + .get("/api/users/{id}/orders") + .then() + .statusCode(200) + .body("orders", isA(java.util.List.class)) + .body("orders[0].id", notNullValue()) + .body("orders[0].status", isIn(Arrays.asList( + "pending", "paid", "shipped", "delivered", "cancelled" + ))) + .body("total", greaterThanOrEqualTo(0)); + } + + @Test + public void invalidRequestShouldReturn400() { + String invalidUser = """ + { + "email": "not-an-email", + "age": -5 + } + """; + + given() + .contentType("application/json") + .body(invalidUser) + .when() + .post("/api/users") + .then() + .statusCode(400) + .body("error", notNullValue()); + } +} +``` + +### 5. **Contract Testing with Postman** + +```json +// postman-collection.json +{ + "info": { + "name": "User API Contract Tests" + }, + "item": [ + { + "name": "Get User", + "request": { + "method": "GET", + "url": "{{baseUrl}}/users/{{userId}}" + }, + "test": " + pm.test('Response status is 200', () => { + pm.response.to.have.status(200); + }); + + pm.test('Response matches schema', () => { + const schema = { + type: 'object', + required: ['id', 'email', 'name'], + properties: { + id: { type: 'string' }, + email: { type: 'string', format: 'email' }, + name: { type: 'string' }, + age: { type: 'integer' } + } + }; + + pm.response.to.have.jsonSchema(schema); + }); + + pm.test('Email format is valid', () => { + const data = pm.response.json(); + pm.expect(data.email).to.match(/^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$/); + }); + " + } + ] +} +``` + +### 6. **Pact Broker Integration** + +```yaml +# .github/workflows/contract-tests.yml +name: Contract Tests + +on: [push, pull_request] + +jobs: + consumer-tests: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + - uses: actions/setup-node@v3 + + - run: npm ci + - run: npm run test:pact + + - name: Publish Pacts + run: | + npx pact-broker publish ./pacts \ + --consumer-app-version=${{ github.sha }} \ + --broker-base-url=${{ secrets.PACT_BROKER_URL }} \ + --broker-token=${{ secrets.PACT_BROKER_TOKEN }} + + provider-tests: + runs-on: ubuntu-latest + needs: consumer-tests + steps: + - uses: actions/checkout@v3 + - uses: actions/setup-node@v3 + + - run: npm ci + - run: npm run test:pact:provider + + - name: Can I Deploy? + run: | + npx pact-broker can-i-deploy \ + --pacticipant=UserService \ + --version=${{ github.sha }} \ + --to-environment=production \ + --broker-base-url=${{ secrets.PACT_BROKER_URL }} \ + --broker-token=${{ secrets.PACT_BROKER_TOKEN }} +``` + +## Best Practices + +### ✅ DO +- Test contracts from consumer perspective +- Use matchers for flexible matching +- Validate schema structure, not specific values +- Version your contracts +- Test error responses +- Use Pact broker for contract sharing +- Run contract tests in CI +- Test backward compatibility + +### ❌ DON'T +- Test business logic in contract tests +- Hard-code specific values in contracts +- Skip error scenarios +- Test UI in contract tests +- Ignore contract versioning +- Deploy without contract verification +- Test implementation details +- Mock contract tests + +## Tools + +- **Pact**: Consumer-driven contracts (multiple languages) +- **Spring Cloud Contract**: JVM contract testing +- **OpenAPI/Swagger**: API specification and validation +- **Postman**: API contract testing +- **REST Assured**: Java API testing +- **Dredd**: OpenAPI/API Blueprint testing +- **Spectral**: OpenAPI linting + +## Examples + +See also: integration-testing, api-versioning-strategy, continuous-testing for comprehensive API testing strategies. diff --git a/.agents/skills/api-security-hardening/SKILL.md b/.agents/skills/api-security-hardening/SKILL.md new file mode 100644 index 00000000..d2a07b42 --- /dev/null +++ b/.agents/skills/api-security-hardening/SKILL.md @@ -0,0 +1,659 @@ +--- +name: api-security-hardening +description: Secure REST APIs with authentication, rate limiting, CORS, input validation, and security middleware. Use when building or hardening API endpoints against common attacks. +--- + +# API Security Hardening + +## Overview + +Implement comprehensive API security measures including authentication, authorization, rate limiting, input validation, and attack prevention to protect against common vulnerabilities. + +## When to Use + +- New API development +- Security audit remediation +- Production API hardening +- Compliance requirements +- High-traffic API protection +- Public API exposure + +## Implementation Examples + +### 1. **Node.js/Express API Security** + +```javascript +// secure-api.js - Comprehensive API security +const express = require('express'); +const helmet = require('helmet'); +const rateLimit = require('express-rate-limit'); +const mongoSanitize = require('express-mongo-sanitize'); +const xss = require('xss-clean'); +const hpp = require('hpp'); +const cors = require('cors'); +const jwt = require('jsonwebtoken'); +const validator = require('validator'); + +class SecureAPIServer { + constructor() { + this.app = express(); + this.setupSecurityMiddleware(); + this.setupRoutes(); + } + + setupSecurityMiddleware() { + // 1. Helmet - Set security headers + this.app.use(helmet({ + contentSecurityPolicy: { + directives: { + defaultSrc: ["'self'"], + styleSrc: ["'self'", "'unsafe-inline'"], + scriptSrc: ["'self'"], + imgSrc: ["'self'", "data:", "https:"] + } + }, + hsts: { + maxAge: 31536000, + includeSubDomains: true, + preload: true + } + })); + + // 2. CORS configuration + const corsOptions = { + origin: (origin, callback) => { + const whitelist = [ + 'https://example.com', + 'https://app.example.com' + ]; + + if (!origin || whitelist.includes(origin)) { + callback(null, true); + } else { + callback(new Error('Not allowed by CORS')); + } + }, + credentials: true, + optionsSuccessStatus: 200, + methods: ['GET', 'POST', 'PUT', 'DELETE'], + allowedHeaders: ['Content-Type', 'Authorization'] + }; + + this.app.use(cors(corsOptions)); + + // 3. Rate limiting + const generalLimiter = rateLimit({ + windowMs: 15 * 60 * 1000, // 15 minutes + max: 100, // limit each IP to 100 requests per windowMs + message: 'Too many requests from this IP', + standardHeaders: true, + legacyHeaders: false, + handler: (req, res) => { + res.status(429).json({ + error: 'rate_limit_exceeded', + message: 'Too many requests, please try again later', + retryAfter: req.rateLimit.resetTime + }); + } + }); + + const authLimiter = rateLimit({ + windowMs: 15 * 60 * 1000, + max: 5, // Stricter limit for auth endpoints + skipSuccessfulRequests: true + }); + + this.app.use('/api/', generalLimiter); + this.app.use('/api/auth/', authLimiter); + + // 4. Body parsing with size limits + this.app.use(express.json({ limit: '10kb' })); + this.app.use(express.urlencoded({ extended: true, limit: '10kb' })); + + // 5. NoSQL injection prevention + this.app.use(mongoSanitize()); + + // 6. XSS protection + this.app.use(xss()); + + // 7. HTTP Parameter Pollution prevention + this.app.use(hpp()); + + // 8. Request ID for tracking + this.app.use((req, res, next) => { + req.id = require('crypto').randomUUID(); + res.setHeader('X-Request-ID', req.id); + next(); + }); + + // 9. Security logging + this.app.use(this.securityLogger()); + } + + securityLogger() { + return (req, res, next) => { + const startTime = Date.now(); + + res.on('finish', () => { + const duration = Date.now() - startTime; + + const logEntry = { + timestamp: new Date().toISOString(), + requestId: req.id, + method: req.method, + path: req.path, + statusCode: res.statusCode, + duration, + ip: req.ip, + userAgent: req.get('user-agent') + }; + + // Log suspicious activity + if (res.statusCode === 401 || res.statusCode === 403) { + console.warn('Security event:', logEntry); + } + + if (res.statusCode >= 500) { + console.error('Server error:', logEntry); + } + }); + + next(); + }; + } + + // JWT authentication middleware + authenticateJWT() { + return (req, res, next) => { + const authHeader = req.headers.authorization; + + if (!authHeader || !authHeader.startsWith('Bearer ')) { + return res.status(401).json({ + error: 'unauthorized', + message: 'Missing or invalid authorization header' + }); + } + + const token = authHeader.substring(7); + + try { + const decoded = jwt.verify(token, process.env.JWT_SECRET, { + algorithms: ['HS256'], + issuer: 'api.example.com', + audience: 'api.example.com' + }); + + req.user = decoded; + next(); + } catch (error) { + if (error.name === 'TokenExpiredError') { + return res.status(401).json({ + error: 'token_expired', + message: 'Token has expired' + }); + } + + return res.status(401).json({ + error: 'invalid_token', + message: 'Invalid token' + }); + } + }; + } + + // Input validation middleware + validateInput(schema) { + return (req, res, next) => { + const errors = []; + + // Validate request body + if (schema.body) { + for (const [field, rules] of Object.entries(schema.body)) { + const value = req.body[field]; + + if (rules.required && !value) { + errors.push(`${field} is required`); + continue; + } + + if (value) { + // Type validation + if (rules.type === 'email' && !validator.isEmail(value)) { + errors.push(`${field} must be a valid email`); + } + + if (rules.type === 'uuid' && !validator.isUUID(value)) { + errors.push(`${field} must be a valid UUID`); + } + + if (rules.type === 'url' && !validator.isURL(value)) { + errors.push(`${field} must be a valid URL`); + } + + // Length validation + if (rules.minLength && value.length < rules.minLength) { + errors.push(`${field} must be at least ${rules.minLength} characters`); + } + + if (rules.maxLength && value.length > rules.maxLength) { + errors.push(`${field} must be at most ${rules.maxLength} characters`); + } + + // Pattern validation + if (rules.pattern && !rules.pattern.test(value)) { + errors.push(`${field} format is invalid`); + } + } + } + } + + if (errors.length > 0) { + return res.status(400).json({ + error: 'validation_error', + message: 'Input validation failed', + details: errors + }); + } + + next(); + }; + } + + // Authorization middleware + authorize(...roles) { + return (req, res, next) => { + if (!req.user) { + return res.status(401).json({ + error: 'unauthorized', + message: 'Authentication required' + }); + } + + if (roles.length > 0 && !roles.includes(req.user.role)) { + return res.status(403).json({ + error: 'forbidden', + message: 'Insufficient permissions' + }); + } + + next(); + }; + } + + setupRoutes() { + // Public endpoint + this.app.get('/api/health', (req, res) => { + res.json({ status: 'healthy' }); + }); + + // Protected endpoint with validation + this.app.post('/api/users', + this.authenticateJWT(), + this.authorize('admin'), + this.validateInput({ + body: { + email: { required: true, type: 'email' }, + name: { required: true, minLength: 2, maxLength: 100 }, + password: { required: true, minLength: 8 } + } + }), + async (req, res) => { + try { + // Sanitized and validated input + const { email, name, password } = req.body; + + // Process request + res.status(201).json({ + message: 'User created successfully', + userId: '123' + }); + } catch (error) { + res.status(500).json({ + error: 'internal_error', + message: 'An error occurred' + }); + } + } + ); + + // Error handling middleware + this.app.use((err, req, res, next) => { + console.error('Unhandled error:', err); + + res.status(500).json({ + error: 'internal_error', + message: 'An unexpected error occurred', + requestId: req.id + }); + }); + } + + start(port = 3000) { + this.app.listen(port, () => { + console.log(`Secure API server running on port ${port}`); + }); + } +} + +// Usage +const server = new SecureAPIServer(); +server.start(3000); +``` + +### 2. **Python FastAPI Security** + +```python +# secure_api.py +from fastapi import FastAPI, HTTPException, Depends, Security, status +from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials +from fastapi.middleware.cors import CORSMiddleware +from fastapi.middleware.trustedhost import TrustedHostMiddleware +from slowapi import Limiter, _rate_limit_exceeded_handler +from slowapi.util import get_remote_address +from slowapi.errors import RateLimitExceeded +from pydantic import BaseModel, EmailStr, validator, Field +import jwt +from datetime import datetime, timedelta +import re +from typing import Optional, List +import secrets + +app = FastAPI() +security = HTTPBearer() +limiter = Limiter(key_func=get_remote_address) + +# Rate limiting +app.state.limiter = limiter +app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler) + +# CORS configuration +app.add_middleware( + CORSMiddleware, + allow_origins=[ + "https://example.com", + "https://app.example.com" + ], + allow_credentials=True, + allow_methods=["GET", "POST", "PUT", "DELETE"], + allow_headers=["Content-Type", "Authorization"], + max_age=3600 +) + +# Trusted hosts +app.add_middleware( + TrustedHostMiddleware, + allowed_hosts=["example.com", "*.example.com"] +) + +# Security headers middleware +@app.middleware("http") +async def add_security_headers(request, call_next): + response = await call_next(request) + + response.headers["X-Content-Type-Options"] = "nosniff" + response.headers["X-Frame-Options"] = "DENY" + response.headers["X-XSS-Protection"] = "1; mode=block" + response.headers["Strict-Transport-Security"] = "max-age=31536000; includeSubDomains" + response.headers["Content-Security-Policy"] = "default-src 'self'" + response.headers["Referrer-Policy"] = "strict-origin-when-cross-origin" + response.headers["Permissions-Policy"] = "geolocation=(), microphone=(), camera=()" + + return response + +# Input validation models +class CreateUserRequest(BaseModel): + email: EmailStr + name: str = Field(..., min_length=2, max_length=100) + password: str = Field(..., min_length=8) + + @validator('password') + def validate_password(cls, v): + if not re.search(r'[A-Z]', v): + raise ValueError('Password must contain uppercase letter') + if not re.search(r'[a-z]', v): + raise ValueError('Password must contain lowercase letter') + if not re.search(r'\d', v): + raise ValueError('Password must contain digit') + if not re.search(r'[!@#$%^&*]', v): + raise ValueError('Password must contain special character') + return v + + @validator('name') + def validate_name(cls, v): + # Prevent XSS in name field + if re.search(r'[<>]', v): + raise ValueError('Name contains invalid characters') + return v + +class APIKeyRequest(BaseModel): + name: str = Field(..., max_length=100) + expires_in_days: int = Field(30, ge=1, le=365) + +# JWT token verification +def verify_token(credentials: HTTPAuthorizationCredentials = Security(security)): + try: + token = credentials.credentials + + payload = jwt.decode( + token, + "your-secret-key", + algorithms=["HS256"], + audience="api.example.com", + issuer="api.example.com" + ) + + return payload + + except jwt.ExpiredSignatureError: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="Token has expired" + ) + except jwt.InvalidTokenError: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="Invalid token" + ) + +# Role-based authorization +def require_role(required_roles: List[str]): + def role_checker(token_payload: dict = Depends(verify_token)): + user_role = token_payload.get('role') + + if user_role not in required_roles: + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail="Insufficient permissions" + ) + + return token_payload + + return role_checker + +# API key authentication +def verify_api_key(api_key: str): + # Constant-time comparison to prevent timing attacks + if not secrets.compare_digest(api_key, "expected-api-key"): + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="Invalid API key" + ) + return True + +# Endpoints +@app.get("/api/health") +@limiter.limit("100/minute") +async def health_check(): + return {"status": "healthy"} + +@app.post("/api/users") +@limiter.limit("10/minute") +async def create_user( + user: CreateUserRequest, + token_payload: dict = Depends(require_role(["admin"])) +): + """Create new user (admin only)""" + + # Hash password before storing + # hashed_password = bcrypt.hashpw(user.password.encode(), bcrypt.gensalt()) + + return { + "message": "User created successfully", + "user_id": "123" + } + +@app.post("/api/keys") +@limiter.limit("5/hour") +async def create_api_key( + request: APIKeyRequest, + token_payload: dict = Depends(verify_token) +): + """Generate API key""" + + # Generate secure random API key + api_key = secrets.token_urlsafe(32) + + expires_at = datetime.now() + timedelta(days=request.expires_in_days) + + return { + "api_key": api_key, + "expires_at": expires_at.isoformat(), + "name": request.name + } + +@app.get("/api/protected") +async def protected_endpoint(token_payload: dict = Depends(verify_token)): + return { + "message": "Access granted", + "user_id": token_payload.get("sub") + } + +if __name__ == "__main__": + import uvicorn + uvicorn.run(app, host="0.0.0.0", port=8000, ssl_certfile="cert.pem", ssl_keyfile="key.pem") +``` + +### 3. **API Gateway Security Configuration** + +```yaml +# nginx-api-gateway.conf +# Nginx API Gateway with security hardening + +http { + # Security headers + add_header X-Frame-Options "DENY" always; + add_header X-Content-Type-Options "nosniff" always; + add_header X-XSS-Protection "1; mode=block" always; + add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always; + add_header Content-Security-Policy "default-src 'self'" always; + + # Rate limiting zones + limit_req_zone $binary_remote_addr zone=api_limit:10m rate=10r/s; + limit_req_zone $binary_remote_addr zone=auth_limit:10m rate=1r/s; + limit_conn_zone $binary_remote_addr zone=conn_limit:10m; + + # Request body size limit + client_max_body_size 10M; + client_body_buffer_size 128k; + + # Timeout settings + client_body_timeout 12; + client_header_timeout 12; + send_timeout 10; + + server { + listen 443 ssl http2; + server_name api.example.com; + + # SSL configuration + ssl_certificate /etc/ssl/certs/api.example.com.crt; + ssl_certificate_key /etc/ssl/private/api.example.com.key; + ssl_protocols TLSv1.2 TLSv1.3; + ssl_ciphers HIGH:!aNULL:!MD5; + ssl_prefer_server_ciphers on; + ssl_session_cache shared:SSL:10m; + ssl_session_timeout 10m; + + # API endpoints + location /api/ { + # Rate limiting + limit_req zone=api_limit burst=20 nodelay; + limit_conn conn_limit 10; + + # CORS headers + add_header Access-Control-Allow-Origin "https://app.example.com" always; + add_header Access-Control-Allow-Methods "GET, POST, PUT, DELETE" always; + add_header Access-Control-Allow-Headers "Authorization, Content-Type" always; + + # Block common exploits + if ($request_method !~ ^(GET|POST|PUT|DELETE|HEAD)$ ) { + return 444; + } + + # Proxy to backend + proxy_pass http://backend:3000; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header X-Forwarded-Proto $scheme; + + # Timeouts + proxy_connect_timeout 60s; + proxy_send_timeout 60s; + proxy_read_timeout 60s; + } + + # Auth endpoints with stricter limits + location /api/auth/ { + limit_req zone=auth_limit burst=5 nodelay; + + proxy_pass http://backend:3000; + } + + # Block access to sensitive files + location ~ /\. { + deny all; + return 404; + } + } +} +``` + +## Best Practices + +### ✅ DO +- Use HTTPS everywhere +- Implement rate limiting +- Validate all inputs +- Use security headers +- Log security events +- Implement CORS properly +- Use strong authentication +- Version your APIs + +### ❌ DON'T +- Expose stack traces +- Return detailed errors +- Trust user input +- Use HTTP for APIs +- Skip input validation +- Ignore rate limiting + +## Security Checklist + +- [ ] HTTPS enforced +- [ ] Authentication required +- [ ] Authorization implemented +- [ ] Rate limiting active +- [ ] Input validation +- [ ] CORS configured +- [ ] Security headers set +- [ ] Error handling secure +- [ ] Logging enabled +- [ ] API versioning + +## Resources + +- [OWASP API Security Top 10](https://owasp.org/www-project-api-security/) +- [API Security Best Practices](https://github.com/shieldfy/API-Security-Checklist) +- [JWT Best Practices](https://tools.ietf.org/html/rfc8725) diff --git a/.agents/skills/database-migration-management/SKILL.md b/.agents/skills/database-migration-management/SKILL.md new file mode 100644 index 00000000..6ea014a2 --- /dev/null +++ b/.agents/skills/database-migration-management/SKILL.md @@ -0,0 +1,384 @@ +--- +name: database-migration-management +description: Manage database migrations and schema versioning. Use when planning migrations, version control, rollback strategies, or data transformations in PostgreSQL and MySQL. +--- + +# Database Migration Management + +## Overview + +Implement robust database migration systems with version control, rollback capabilities, and data transformation strategies. Includes migration frameworks and production deployment patterns. + +## When to Use + +- Schema versioning and evolution +- Data transformations and cleanup +- Adding/removing tables and columns +- Index creation and optimization +- Migration testing and validation +- Rollback planning and execution +- Multi-environment deployments + +## Migration Framework Setup + +### PostgreSQL - Schema Versioning + +```sql +-- Create migrations tracking table +CREATE TABLE schema_migrations ( + version BIGINT PRIMARY KEY, + name VARCHAR(255) NOT NULL, + executed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + duration_ms INTEGER, + checksum VARCHAR(64) +); + +-- Create migration log table +CREATE TABLE migration_logs ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + version BIGINT NOT NULL, + status VARCHAR(20) NOT NULL, + error_message TEXT, + rolled_back_at TIMESTAMP, + executed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP +); + +-- Function to record migration +CREATE OR REPLACE FUNCTION record_migration( + p_version BIGINT, + p_name VARCHAR, + p_duration_ms INTEGER +) RETURNS void AS $$ +BEGIN + INSERT INTO schema_migrations (version, name, duration_ms) + VALUES (p_version, p_name, p_duration_ms) + ON CONFLICT (version) DO UPDATE + SET executed_at = CURRENT_TIMESTAMP; +END; +$$ LANGUAGE plpgsql; +``` + +### MySQL - Migration Tracking + +```sql +-- Create migrations table for MySQL +CREATE TABLE schema_migrations ( + version BIGINT PRIMARY KEY, + name VARCHAR(255) NOT NULL, + executed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + duration_ms INT, + checksum VARCHAR(64) +) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4; + +-- Migration status table +CREATE TABLE migration_status ( + id INT AUTO_INCREMENT PRIMARY KEY, + version BIGINT NOT NULL, + status ENUM('pending', 'completed', 'failed', 'rolled_back'), + error_message TEXT, + created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP +) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4; +``` + +## Common Migration Patterns + +### Adding Columns + +**PostgreSQL - Safe Column Addition:** + +```sql +-- Migration: 20240115_001_add_phone_to_users.sql + +-- Add column with default (non-blocking) +ALTER TABLE users +ADD COLUMN phone VARCHAR(20) DEFAULT ''; + +-- Add constraint after population +ALTER TABLE users +ADD CONSTRAINT phone_format +CHECK (phone = '' OR phone ~ '^\+?[0-9\-\(\)]{10,}$'); + +-- Create index +CREATE INDEX CONCURRENTLY idx_users_phone ON users(phone); + +-- Rollback: +-- DROP INDEX CONCURRENTLY idx_users_phone; +-- ALTER TABLE users DROP COLUMN phone; +``` + +**MySQL - Column Addition:** + +```sql +-- Migration: 20240115_001_add_phone_to_users.sql + +-- Add column with ALTER +ALTER TABLE users +ADD COLUMN phone VARCHAR(20) DEFAULT '', +ADD INDEX idx_phone (phone); + +-- Rollback: +-- ALTER TABLE users DROP COLUMN phone; +``` + +### Renaming Columns + +**PostgreSQL - Column Rename:** + +```sql +-- Migration: 20240115_002_rename_user_name_columns.sql + +-- Rename columns +ALTER TABLE users RENAME COLUMN user_name TO full_name; +ALTER TABLE users RENAME COLUMN user_email TO email_address; + +-- Update indexes +REINDEX TABLE users; + +-- Rollback: +-- ALTER TABLE users RENAME COLUMN email_address TO user_email; +-- ALTER TABLE users RENAME COLUMN full_name TO user_name; +``` + +### Creating Indexes Non-blocking + +**PostgreSQL - Concurrent Index Creation:** + +```sql +-- Migration: 20240115_003_add_performance_indexes.sql + +-- Create indexes without blocking writes +CREATE INDEX CONCURRENTLY idx_orders_user_created +ON orders(user_id, created_at DESC); + +CREATE INDEX CONCURRENTLY idx_products_category_active +ON products(category_id) +WHERE active = true; + +-- Verify index creation +SELECT schemaname, tablename, indexname, idx_scan +FROM pg_stat_user_indexes +WHERE indexname LIKE 'idx_%'; + +-- Rollback: +-- DROP INDEX CONCURRENTLY idx_orders_user_created; +-- DROP INDEX CONCURRENTLY idx_products_category_active; +``` + +**MySQL - Online Index Creation:** + +```sql +-- Migration: 20240115_003_add_performance_indexes.sql + +-- Create indexes with ALGORITHM=INPLACE and LOCK=NONE +ALTER TABLE orders +ADD INDEX idx_user_created (user_id, created_at), +ALGORITHM=INPLACE, LOCK=NONE; + +-- Monitor progress +SELECT * FROM INFORMATION_SCHEMA.PROCESSLIST +WHERE INFO LIKE 'ALTER TABLE%'; +``` + +### Data Transformations + +**PostgreSQL - Data Cleanup Migration:** + +```sql +-- Migration: 20240115_004_normalize_email_addresses.sql + +-- Normalize existing email addresses +UPDATE users +SET email = LOWER(TRIM(email)) +WHERE email != LOWER(TRIM(email)); + +-- Remove duplicates by keeping latest +DELETE FROM users +WHERE id NOT IN ( + SELECT DISTINCT ON (LOWER(email)) id + FROM users + ORDER BY LOWER(email), created_at DESC +); + +-- Rollback: Restore from backup (no safe rollback for data changes) +``` + +**MySQL - Bulk Data Update:** + +```sql +-- Migration: 20240115_004_update_product_categories.sql + +-- Update multiple rows with JOIN +UPDATE products p +JOIN category_mapping cm ON p.old_category = cm.old_name +SET p.category_id = cm.new_category_id +WHERE p.old_category IS NOT NULL; + +-- Verify update +SELECT COUNT(*) as updated_count +FROM products +WHERE category_id IS NOT NULL; +``` + +### Table Structure Changes + +**PostgreSQL - Alter Table Migration:** + +```sql +-- Migration: 20240115_005_modify_order_columns.sql + +-- Add new column +ALTER TABLE orders +ADD COLUMN status_updated_at TIMESTAMP; + +-- Add constraint +ALTER TABLE orders +ADD CONSTRAINT valid_status +CHECK (status IN ('pending', 'processing', 'completed', 'cancelled')); + +-- Set default for existing records +UPDATE orders +SET status_updated_at = updated_at +WHERE status_updated_at IS NULL; + +-- Make column NOT NULL +ALTER TABLE orders +ALTER COLUMN status_updated_at SET NOT NULL; + +-- Rollback: +-- ALTER TABLE orders DROP COLUMN status_updated_at; +-- ALTER TABLE orders DROP CONSTRAINT valid_status; +``` + +## Testing Migrations + +**PostgreSQL - Test in Transaction:** + +```sql +-- Test migration in transaction (will be rolled back) +BEGIN; + +-- Run migration statements +ALTER TABLE users ADD COLUMN test_column VARCHAR(255); + +-- Validate data +SELECT COUNT(*) FROM users; +SELECT COUNT(DISTINCT email) FROM users; + +-- Rollback if issues found +ROLLBACK; + +-- Or commit if all good +COMMIT; +``` + +**Validate Migration:** + +```sql +-- Check migration was applied +SELECT version, name, executed_at FROM schema_migrations +WHERE version = 20240115005; + +-- Verify table structure +SELECT column_name, data_type, is_nullable +FROM information_schema.columns +WHERE table_name = 'users' +ORDER BY ordinal_position; +``` + +## Rollback Strategies + +**PostgreSQL - Bidirectional Migrations:** + +```sql +-- Migration file: 20240115_006_add_user_status.sql + +-- ===== UP ===== +CREATE TYPE user_status AS ENUM ('active', 'suspended', 'deleted'); +ALTER TABLE users ADD COLUMN status user_status DEFAULT 'active'; + +-- ===== DOWN ===== +-- ALTER TABLE users DROP COLUMN status; +-- DROP TYPE user_status; +``` + +**Rollback Execution:** + +```sql +-- Function to rollback to specific version +CREATE OR REPLACE FUNCTION rollback_to_version(p_target_version BIGINT) +RETURNS TABLE (version BIGINT, name VARCHAR, status VARCHAR) AS $$ +BEGIN + -- Execute down migrations in reverse order + RETURN QUERY + SELECT m.version, m.name, 'rolled_back'::VARCHAR + FROM schema_migrations m + WHERE m.version > p_target_version + ORDER BY m.version DESC; +END; +$$ LANGUAGE plpgsql; +``` + +## Production Deployment + +**Safe Migration Checklist:** + +- Test migration on production-like database +- Verify backup exists before migration +- Schedule during low-traffic window +- Monitor table locks and long-running queries +- Have rollback plan ready +- Test rollback procedure +- Document all changes +- Run in transaction when possible +- Verify data integrity after migration +- Update application code coordinated with migration + +**PostgreSQL - Long Transaction Safety:** + +```sql +-- Use statement timeout to prevent hanging migrations +SET statement_timeout = '30min'; + +-- Use lock timeout to prevent deadlocks +SET lock_timeout = '5min'; + +-- Run migration with timeouts +ALTER TABLE large_table +ADD COLUMN new_column VARCHAR(255), +ALGORITHM='INPLACE'; +``` + +## Migration Examples + +**Combined Migration - Multiple Changes:** + +```sql +-- Migration: 20240115_007_refactor_user_tables.sql + +BEGIN; + +-- 1. Create new column with data from old column +ALTER TABLE users ADD COLUMN full_name VARCHAR(255); +UPDATE users SET full_name = first_name || ' ' || last_name; + +-- 2. Add indexes +CREATE INDEX idx_users_full_name ON users(full_name); + +-- 3. Add new constraint +ALTER TABLE users +ADD CONSTRAINT email_unique UNIQUE(email); + +-- 4. Drop old columns (after verification) +-- ALTER TABLE users DROP COLUMN first_name; +-- ALTER TABLE users DROP COLUMN last_name; + +COMMIT; +``` + +## Resources + +- [Flyway - Java Migration Tool](https://flywaydb.org/) +- [Liquibase - Database Changelog](https://www.liquibase.org/) +- [Alembic - Python Migration](https://alembic.sqlalchemy.org/) +- [PostgreSQL ALTER TABLE](https://www.postgresql.org/docs/current/sql-altertable.html) +- [MySQL ALTER TABLE](https://dev.mysql.com/doc/refman/8.0/en/alter-table.html) diff --git a/.agents/skills/find-skills/SKILL.md b/.agents/skills/find-skills/SKILL.md new file mode 100644 index 00000000..c797184e --- /dev/null +++ b/.agents/skills/find-skills/SKILL.md @@ -0,0 +1,133 @@ +--- +name: find-skills +description: Helps users discover and install agent skills when they ask questions like "how do I do X", "find a skill for X", "is there a skill that can...", or express interest in extending capabilities. This skill should be used when the user is looking for functionality that might exist as an installable skill. +--- + +# Find Skills + +This skill helps you discover and install skills from the open agent skills ecosystem. + +## When to Use This Skill + +Use this skill when the user: + +- Asks "how do I do X" where X might be a common task with an existing skill +- Says "find a skill for X" or "is there a skill for X" +- Asks "can you do X" where X is a specialized capability +- Expresses interest in extending agent capabilities +- Wants to search for tools, templates, or workflows +- Mentions they wish they had help with a specific domain (design, testing, deployment, etc.) + +## What is the Skills CLI? + +The Skills CLI (`npx skills`) is the package manager for the open agent skills ecosystem. Skills are modular packages that extend agent capabilities with specialized knowledge, workflows, and tools. + +**Key commands:** + +- `npx skills find [query]` - Search for skills interactively or by keyword +- `npx skills add ` - Install a skill from GitHub or other sources +- `npx skills check` - Check for skill updates +- `npx skills update` - Update all installed skills + +**Browse skills at:** https://skills.sh/ + +## How to Help Users Find Skills + +### Step 1: Understand What They Need + +When a user asks for help with something, identify: + +1. The domain (e.g., React, testing, design, deployment) +2. The specific task (e.g., writing tests, creating animations, reviewing PRs) +3. Whether this is a common enough task that a skill likely exists + +### Step 2: Search for Skills + +Run the find command with a relevant query: + +```bash +npx skills find [query] +``` + +For example: + +- User asks "how do I make my React app faster?" → `npx skills find react performance` +- User asks "can you help me with PR reviews?" → `npx skills find pr review` +- User asks "I need to create a changelog" → `npx skills find changelog` + +The command will return results like: + +``` +Install with npx skills add + +vercel-labs/agent-skills@vercel-react-best-practices +└ https://skills.sh/vercel-labs/agent-skills/vercel-react-best-practices +``` + +### Step 3: Present Options to the User + +When you find relevant skills, present them to the user with: + +1. The skill name and what it does +2. The install command they can run +3. A link to learn more at skills.sh + +Example response: + +``` +I found a skill that might help! The "vercel-react-best-practices" skill provides +React and Next.js performance optimization guidelines from Vercel Engineering. + +To install it: +npx skills add vercel-labs/agent-skills@vercel-react-best-practices + +Learn more: https://skills.sh/vercel-labs/agent-skills/vercel-react-best-practices +``` + +### Step 4: Offer to Install + +If the user wants to proceed, you can install the skill for them: + +```bash +npx skills add -g -y +``` + +The `-g` flag installs globally (user-level) and `-y` skips confirmation prompts. + +## Common Skill Categories + +When searching, consider these common categories: + +| Category | Example Queries | +| --------------- | ---------------------------------------- | +| Web Development | react, nextjs, typescript, css, tailwind | +| Testing | testing, jest, playwright, e2e | +| DevOps | deploy, docker, kubernetes, ci-cd | +| Documentation | docs, readme, changelog, api-docs | +| Code Quality | review, lint, refactor, best-practices | +| Design | ui, ux, design-system, accessibility | +| Productivity | workflow, automation, git | + +## Tips for Effective Searches + +1. **Use specific keywords**: "react testing" is better than just "testing" +2. **Try alternative terms**: If "deploy" doesn't work, try "deployment" or "ci-cd" +3. **Check popular sources**: Many skills come from `vercel-labs/agent-skills` or `ComposioHQ/awesome-claude-skills` + +## When No Skills Are Found + +If no relevant skills exist: + +1. Acknowledge that no existing skill was found +2. Offer to help with the task directly using your general capabilities +3. Suggest the user could create their own skill with `npx skills init` + +Example: + +``` +I searched for skills related to "xyz" but didn't find any matches. +I can still help you with this task directly! Would you like me to proceed? + +If this is something you do often, you could create your own skill: +npx skills init my-xyz-skill +``` diff --git a/.agents/skills/gcp-cloud-run/SKILL.md b/.agents/skills/gcp-cloud-run/SKILL.md new file mode 100644 index 00000000..bd344b3c --- /dev/null +++ b/.agents/skills/gcp-cloud-run/SKILL.md @@ -0,0 +1,292 @@ +--- +name: gcp-cloud-run +description: "Specialized skill for building production-ready serverless applications on GCP. Covers Cloud Run services (containerized), Cloud Run Functions (event-driven), cold start optimization, and event-dri..." +source: vibeship-spawner-skills (Apache 2.0) +risk: unknown +--- + +# GCP Cloud Run + +## Patterns + +### Cloud Run Service Pattern + +Containerized web service on Cloud Run + +**When to use**: ['Web applications and APIs', 'Need any runtime or library', 'Complex services with multiple endpoints', 'Stateless containerized workloads'] + +```javascript +```dockerfile +# Dockerfile - Multi-stage build for smaller image +FROM node:20-slim AS builder +WORKDIR /app +COPY package*.json ./ +RUN npm ci --only=production + +FROM node:20-slim +WORKDIR /app + +# Copy only production dependencies +COPY --from=builder /app/node_modules ./node_modules +COPY src ./src +COPY package.json ./ + +# Cloud Run uses PORT env variable +ENV PORT=8080 +EXPOSE 8080 + +# Run as non-root user +USER node + +CMD ["node", "src/index.js"] +``` + +```javascript +// src/index.js +const express = require('express'); +const app = express(); + +app.use(express.json()); + +// Health check endpoint +app.get('/health', (req, res) => { + res.status(200).send('OK'); +}); + +// API routes +app.get('/api/items/:id', async (req, res) => { + try { + const item = await getItem(req.params.id); + res.json(item); + } catch (error) { + console.error('Error:', error); + res.status(500).json({ error: 'Internal server error' }); + } +}); + +// Graceful shutdown +process.on('SIGTERM', () => { + console.log('SIGTERM received, shutting down gracefully'); + server.close(() => { + console.log('Server closed'); + process.exit(0); + }); +}); + +const PORT = process.env.PORT || 8080; +const server = app.listen(PORT, () => { + console.log(`Server listening on port ${PORT}`); +}); +``` + +```yaml +# cloudbuild.yaml +steps: + # Build the container image + - name: 'gcr.io/cloud-builders/docker' + args: ['build', '-t', 'gcr.io/$PROJECT_ID/my-service:$COMMIT_SHA', '.'] + + # Push the container image + - name: 'gcr.io/cloud-builders/docker' + args: ['push', 'gcr.io/$PROJECT_ID/my-service:$COMMIT_SHA'] + + # Deploy to Cloud Run + - name: 'gcr.io/google.com/cloudsdktool/cloud-sdk' + entrypoint: gcloud + args: + - 'run' + - 'deploy' + - 'my-service' + - '--image=gcr.io/$PROJECT_ID/my-service:$COMMIT_SHA' + - '--region=us-central1' + - '--platform=managed' + - '--allow-unauthenticated' + - '--memory=512Mi' + - '--cpu=1' + - '--min-instances=1' + - '--max-instances=100' + +``` + +### Cloud Run Functions Pattern + +Event-driven functions (formerly Cloud Functions) + +**When to use**: ['Simple event handlers', 'Pub/Sub message processing', 'Cloud Storage triggers', 'HTTP webhooks'] + +```javascript +```javascript +// HTTP Function +// index.js +const functions = require('@google-cloud/functions-framework'); + +functions.http('helloHttp', (req, res) => { + const name = req.query.name || req.body.name || 'World'; + res.send(`Hello, ${name}!`); +}); +``` + +```javascript +// Pub/Sub Function +const functions = require('@google-cloud/functions-framework'); + +functions.cloudEvent('processPubSub', (cloudEvent) => { + // Decode Pub/Sub message + const message = cloudEvent.data.message; + const data = message.data + ? JSON.parse(Buffer.from(message.data, 'base64').toString()) + : {}; + + console.log('Received message:', data); + + // Process message + processMessage(data); +}); +``` + +```javascript +// Cloud Storage Function +const functions = require('@google-cloud/functions-framework'); + +functions.cloudEvent('processStorageEvent', async (cloudEvent) => { + const file = cloudEvent.data; + + console.log(`Event: ${cloudEvent.type}`); + console.log(`Bucket: ${file.bucket}`); + console.log(`File: ${file.name}`); + + if (cloudEvent.type === 'google.cloud.storage.object.v1.finalized') { + await processUploadedFile(file.bucket, file.name); + } +}); +``` + +```bash +# Deploy HTTP function +gcloud functions deploy hello-http \ + --gen2 \ + --runtime nodejs20 \ + --trigger-http \ + --allow-unauthenticated \ + --region us-central1 + +# Deploy Pub/Sub function +gcloud functions deploy process-messages \ + --gen2 \ + --runtime nodejs20 \ + --trigger-topic my-topic \ + --region us-central1 + +# Deploy Cloud Storage function +gcloud functions deploy process-uploads \ + --gen2 \ + --runtime nodejs20 \ + --trigger-event-filters="type=google.cloud.storage.object.v1.finalized" \ + --trigger-event-filters="bucket=my-bucket" \ + --region us-central1 +``` +``` + +### Cold Start Optimization Pattern + +Minimize cold start latency for Cloud Run + +**When to use**: ['Latency-sensitive applications', 'User-facing APIs', 'High-traffic services'] + +```javascript +## 1. Enable Startup CPU Boost + +```bash +gcloud run deploy my-service \ + --cpu-boost \ + --region us-central1 +``` + +## 2. Set Minimum Instances + +```bash +gcloud run deploy my-service \ + --min-instances 1 \ + --region us-central1 +``` + +## 3. Optimize Container Image + +```dockerfile +# Use distroless for minimal image +FROM node:20-slim AS builder +WORKDIR /app +COPY package*.json ./ +RUN npm ci --only=production + +FROM gcr.io/distroless/nodejs20-debian12 +WORKDIR /app +COPY --from=builder /app/node_modules ./node_modules +COPY src ./src +CMD ["src/index.js"] +``` + +## 4. Lazy Initialize Heavy Dependencies + +```javascript +// Lazy load heavy libraries +let bigQueryClient = null; + +function getBigQueryClient() { + if (!bigQueryClient) { + const { BigQuery } = require('@google-cloud/bigquery'); + bigQueryClient = new BigQuery(); + } + return bigQueryClient; +} + +// Only initialize when needed +app.get('/api/analytics', async (req, res) => { + const client = getBigQueryClient(); + const results = await client.query({...}); + res.json(results); +}); +``` + +## 5. Increase Memory (More CPU) + +```bash +# Higher memory = more CPU during startup +gcloud run deploy my-service \ + --memory 1Gi \ + --cpu 2 \ + --region us-central1 +``` +``` + +## Anti-Patterns + +### ❌ CPU-Intensive Work Without Concurrency=1 + +**Why bad**: CPU is shared across concurrent requests. CPU-bound work +will starve other requests, causing timeouts. + +### ❌ Writing Large Files to /tmp + +**Why bad**: /tmp is an in-memory filesystem. Large files consume +your memory allocation and can cause OOM errors. + +### ❌ Long-Running Background Tasks + +**Why bad**: Cloud Run throttles CPU to near-zero when not handling +requests. Background tasks will be extremely slow or stall. + +## ⚠️ Sharp Edges + +| Issue | Severity | Solution | +|-------|----------|----------| +| Issue | high | ## Calculate memory including /tmp usage | +| Issue | high | ## Set appropriate concurrency | +| Issue | high | ## Enable CPU always allocated | +| Issue | medium | ## Configure connection pool with keep-alive | +| Issue | high | ## Enable startup CPU boost | +| Issue | medium | ## Explicitly set execution environment | +| Issue | medium | ## Set consistent timeouts | + +## When to Use +This skill is applicable to execute the workflow or actions described in the overview. From d6559a0a11f923cc41f1645339c4c42982acf9eb Mon Sep 17 00:00:00 2001 From: zouantchaw <44246692+zouantchaw@users.noreply.github.com> Date: Thu, 26 Feb 2026 12:26:08 -0500 Subject: [PATCH 02/21] feat(backend): add isolated v2 foundation stack and query service scaffold --- .github/workflows/backend-foundation.yml | 9 + CHANGELOG.md | 1 + Makefile | 12 + backend/query-api/Dockerfile | 13 + backend/query-api/package-lock.json | 2901 +++++++++++++++++ backend/query-api/package.json | 22 + backend/query-api/src/app.js | 28 + backend/query-api/src/lib/errors.js | 26 + .../query-api/src/middleware/error-handler.js | 25 + .../src/middleware/request-context.js | 9 + backend/query-api/src/routes/health.js | 15 + backend/query-api/src/server.js | 9 + backend/query-api/test/app.test.js | 24 + makefiles/backend.mk | 211 +- 14 files changed, 3304 insertions(+), 1 deletion(-) create mode 100644 backend/query-api/Dockerfile create mode 100644 backend/query-api/package-lock.json create mode 100644 backend/query-api/package.json create mode 100644 backend/query-api/src/app.js create mode 100644 backend/query-api/src/lib/errors.js create mode 100644 backend/query-api/src/middleware/error-handler.js create mode 100644 backend/query-api/src/middleware/request-context.js create mode 100644 backend/query-api/src/routes/health.js create mode 100644 backend/query-api/src/server.js create mode 100644 backend/query-api/test/app.test.js diff --git a/.github/workflows/backend-foundation.yml b/.github/workflows/backend-foundation.yml index a4a7d777..907d480f 100644 --- a/.github/workflows/backend-foundation.yml +++ b/.github/workflows/backend-foundation.yml @@ -25,6 +25,14 @@ jobs: make -n backend-smoke-core ENV=dev make -n backend-smoke-commands ENV=dev make -n backend-logs-core ENV=dev + make -n backend-bootstrap-v2-dev ENV=dev + make -n backend-deploy-core-v2 ENV=dev + make -n backend-deploy-commands-v2 ENV=dev + make -n backend-deploy-query-v2 ENV=dev + make -n backend-smoke-core-v2 ENV=dev + make -n backend-smoke-commands-v2 ENV=dev + make -n backend-smoke-query-v2 ENV=dev + make -n backend-logs-core-v2 ENV=dev backend-services-tests: runs-on: ubuntu-latest @@ -33,6 +41,7 @@ jobs: service: - backend/core-api - backend/command-api + - backend/query-api defaults: run: working-directory: ${{ matrix.service }} diff --git a/CHANGELOG.md b/CHANGELOG.md index b3b40911..e349edbd 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -28,3 +28,4 @@ | 2026-02-25 | 0.1.23 | Updated schema blueprint and reconciliation docs to add `business_memberships` and `vendor_memberships` as first-class data actors. | | 2026-02-25 | 0.1.24 | Removed stale `m4-discrepencies.md` document from M4 planning docs cleanup. | | 2026-02-25 | 0.1.25 | Added target schema model catalog with keys and domain relationship diagrams for slide/workshop use. | +| 2026-02-26 | 0.1.26 | Added isolated v2 backend foundation targets, scaffolded `backend/query-api`, and expanded backend CI dry-runs/tests for v2/query. | diff --git a/Makefile b/Makefile index 98d82e42..d19df67e 100644 --- a/Makefile +++ b/Makefile @@ -89,6 +89,18 @@ help: @echo " make backend-smoke-commands [ENV=dev] Run health smoke test for command service (/health)" @echo " make backend-logs-core [ENV=dev] Tail/read logs for core service" @echo "" + @echo " ☁️ BACKEND FOUNDATION V2 (Isolated Parallel Stack)" + @echo " ────────────────────────────────────────────────────────────────────" + @echo " make backend-bootstrap-v2-dev [ENV=dev] Bootstrap isolated v2 resources + SQL instance" + @echo " make backend-deploy-core-v2 [ENV=dev] Build and deploy core API v2 service" + @echo " make backend-deploy-commands-v2 [ENV=dev] Build and deploy command API v2 service" + @echo " make backend-deploy-query-v2 [ENV=dev] Build and deploy query API v2 scaffold" + @echo " make backend-v2-migrate-idempotency Create/upgrade command idempotency table for v2 DB" + @echo " make backend-smoke-core-v2 [ENV=dev] Run health smoke test for core API v2 (/health)" + @echo " make backend-smoke-commands-v2 [ENV=dev] Run health smoke test for command API v2 (/health)" + @echo " make backend-smoke-query-v2 [ENV=dev] Run health smoke test for query API v2 (/health)" + @echo " make backend-logs-core-v2 [ENV=dev] Tail/read logs for core API v2" + @echo "" @echo " 🛠️ DEVELOPMENT TOOLS" @echo " ────────────────────────────────────────────────────────────────────" @echo " make install-melos Install Melos globally (for mobile dev)" diff --git a/backend/query-api/Dockerfile b/backend/query-api/Dockerfile new file mode 100644 index 00000000..55a6a26b --- /dev/null +++ b/backend/query-api/Dockerfile @@ -0,0 +1,13 @@ +FROM node:20-alpine + +WORKDIR /app + +COPY package*.json ./ +RUN npm ci --omit=dev + +COPY src ./src + +ENV PORT=8080 +EXPOSE 8080 + +CMD ["node", "src/server.js"] diff --git a/backend/query-api/package-lock.json b/backend/query-api/package-lock.json new file mode 100644 index 00000000..c74c9764 --- /dev/null +++ b/backend/query-api/package-lock.json @@ -0,0 +1,2901 @@ +{ + "name": "@krow/query-api", + "version": "0.1.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "@krow/query-api", + "version": "0.1.0", + "dependencies": { + "express": "^4.21.2", + "firebase-admin": "^13.0.2", + "pino": "^9.6.0", + "pino-http": "^10.3.0" + }, + "devDependencies": { + "supertest": "^7.0.0" + }, + "engines": { + "node": ">=20" + } + }, + "node_modules/@fastify/busboy": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/@fastify/busboy/-/busboy-3.2.0.tgz", + "integrity": "sha512-m9FVDXU3GT2ITSe0UaMA5rU3QkfC/UXtCU8y0gSN/GugTqtVldOBWIB5V6V3sbmenVZUIpU6f+mPEO2+m5iTaA==", + "license": "MIT" + }, + "node_modules/@firebase/app-check-interop-types": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/@firebase/app-check-interop-types/-/app-check-interop-types-0.3.3.tgz", + "integrity": "sha512-gAlxfPLT2j8bTI/qfe3ahl2I2YcBQ8cFIBdhAQA4I2f3TndcO+22YizyGYuttLHPQEpWkhmpFW60VCFEPg4g5A==", + "license": "Apache-2.0" + }, + "node_modules/@firebase/app-types": { + "version": "0.9.3", + "resolved": "https://registry.npmjs.org/@firebase/app-types/-/app-types-0.9.3.tgz", + "integrity": "sha512-kRVpIl4vVGJ4baogMDINbyrIOtOxqhkZQg4jTq3l8Lw6WSk0xfpEYzezFu+Kl4ve4fbPl79dvwRtaFqAC/ucCw==", + "license": "Apache-2.0" + }, + "node_modules/@firebase/auth-interop-types": { + "version": "0.2.4", + "resolved": "https://registry.npmjs.org/@firebase/auth-interop-types/-/auth-interop-types-0.2.4.tgz", + "integrity": "sha512-JPgcXKCuO+CWqGDnigBtvo09HeBs5u/Ktc2GaFj2m01hLarbxthLNm7Fk8iOP1aqAtXV+fnnGj7U28xmk7IwVA==", + "license": "Apache-2.0" + }, + "node_modules/@firebase/component": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/@firebase/component/-/component-0.7.0.tgz", + "integrity": "sha512-wR9En2A+WESUHexjmRHkqtaVH94WLNKt6rmeqZhSLBybg4Wyf0Umk04SZsS6sBq4102ZsDBFwoqMqJYj2IoDSg==", + "license": "Apache-2.0", + "dependencies": { + "@firebase/util": "1.13.0", + "tslib": "^2.1.0" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@firebase/database": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@firebase/database/-/database-1.1.0.tgz", + "integrity": "sha512-gM6MJFae3pTyNLoc9VcJNuaUDej0ctdjn3cVtILo3D5lpp0dmUHHLFN/pUKe7ImyeB1KAvRlEYxvIHNF04Filg==", + "license": "Apache-2.0", + "dependencies": { + "@firebase/app-check-interop-types": "0.3.3", + "@firebase/auth-interop-types": "0.2.4", + "@firebase/component": "0.7.0", + "@firebase/logger": "0.5.0", + "@firebase/util": "1.13.0", + "faye-websocket": "0.11.4", + "tslib": "^2.1.0" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@firebase/database-compat": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/@firebase/database-compat/-/database-compat-2.1.0.tgz", + "integrity": "sha512-8nYc43RqxScsePVd1qe1xxvWNf0OBnbwHxmXJ7MHSuuTVYFO3eLyLW3PiCKJ9fHnmIz4p4LbieXwz+qtr9PZDg==", + "license": "Apache-2.0", + "dependencies": { + "@firebase/component": "0.7.0", + "@firebase/database": "1.1.0", + "@firebase/database-types": "1.0.16", + "@firebase/logger": "0.5.0", + "@firebase/util": "1.13.0", + "tslib": "^2.1.0" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@firebase/database-types": { + "version": "1.0.16", + "resolved": "https://registry.npmjs.org/@firebase/database-types/-/database-types-1.0.16.tgz", + "integrity": "sha512-xkQLQfU5De7+SPhEGAXFBnDryUWhhlFXelEg2YeZOQMCdoe7dL64DDAd77SQsR+6uoXIZY5MB4y/inCs4GTfcw==", + "license": "Apache-2.0", + "dependencies": { + "@firebase/app-types": "0.9.3", + "@firebase/util": "1.13.0" + } + }, + "node_modules/@firebase/logger": { + "version": "0.5.0", + "resolved": "https://registry.npmjs.org/@firebase/logger/-/logger-0.5.0.tgz", + "integrity": "sha512-cGskaAvkrnh42b3BA3doDWeBmuHFO/Mx5A83rbRDYakPjO9bJtRL3dX7javzc2Rr/JHZf4HlterTW2lUkfeN4g==", + "license": "Apache-2.0", + "dependencies": { + "tslib": "^2.1.0" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@firebase/util": { + "version": "1.13.0", + "resolved": "https://registry.npmjs.org/@firebase/util/-/util-1.13.0.tgz", + "integrity": "sha512-0AZUyYUfpMNcztR5l09izHwXkZpghLgCUaAGjtMwXnCg3bj4ml5VgiwqOMOxJ+Nw4qN/zJAaOQBcJ7KGkWStqQ==", + "hasInstallScript": true, + "license": "Apache-2.0", + "dependencies": { + "tslib": "^2.1.0" + }, + "engines": { + "node": ">=20.0.0" + } + }, + "node_modules/@google-cloud/firestore": { + "version": "7.11.6", + "resolved": "https://registry.npmjs.org/@google-cloud/firestore/-/firestore-7.11.6.tgz", + "integrity": "sha512-EW/O8ktzwLfyWBOsNuhRoMi8lrC3clHM5LVFhGvO1HCsLozCOOXRAlHrYBoE6HL42Sc8yYMuCb2XqcnJ4OOEpw==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "@opentelemetry/api": "^1.3.0", + "fast-deep-equal": "^3.1.1", + "functional-red-black-tree": "^1.0.1", + "google-gax": "^4.3.3", + "protobufjs": "^7.2.6" + }, + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/@google-cloud/paginator": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/@google-cloud/paginator/-/paginator-5.0.2.tgz", + "integrity": "sha512-DJS3s0OVH4zFDB1PzjxAsHqJT6sKVbRwwML0ZBP9PbU7Yebtu/7SWMRzvO2J3nUi9pRNITCfu4LJeooM2w4pjg==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "arrify": "^2.0.0", + "extend": "^3.0.2" + }, + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/@google-cloud/projectify": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/@google-cloud/projectify/-/projectify-4.0.0.tgz", + "integrity": "sha512-MmaX6HeSvyPbWGwFq7mXdo0uQZLGBYCwziiLIGq5JVX+/bdI3SAq6bP98trV5eTWfLuvsMcIC1YJOF2vfteLFA==", + "license": "Apache-2.0", + "optional": true, + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/@google-cloud/promisify": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/@google-cloud/promisify/-/promisify-4.0.0.tgz", + "integrity": "sha512-Orxzlfb9c67A15cq2JQEyVc7wEsmFBmHjZWZYQMUyJ1qivXyMwdyNOs9odi79hze+2zqdTtu1E19IM/FtqZ10g==", + "license": "Apache-2.0", + "optional": true, + "engines": { + "node": ">=14" + } + }, + "node_modules/@google-cloud/storage": { + "version": "7.19.0", + "resolved": "https://registry.npmjs.org/@google-cloud/storage/-/storage-7.19.0.tgz", + "integrity": "sha512-n2FjE7NAOYyshogdc7KQOl/VZb4sneqPjWouSyia9CMDdMhRX5+RIbqalNmC7LOLzuLAN89VlF2HvG8na9G+zQ==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "@google-cloud/paginator": "^5.0.0", + "@google-cloud/projectify": "^4.0.0", + "@google-cloud/promisify": "<4.1.0", + "abort-controller": "^3.0.0", + "async-retry": "^1.3.3", + "duplexify": "^4.1.3", + "fast-xml-parser": "^5.3.4", + "gaxios": "^6.0.2", + "google-auth-library": "^9.6.3", + "html-entities": "^2.5.2", + "mime": "^3.0.0", + "p-limit": "^3.0.1", + "retry-request": "^7.0.0", + "teeny-request": "^9.0.0", + "uuid": "^8.0.0" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/@google-cloud/storage/node_modules/uuid": { + "version": "8.3.2", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz", + "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==", + "license": "MIT", + "optional": true, + "bin": { + "uuid": "dist/bin/uuid" + } + }, + "node_modules/@grpc/grpc-js": { + "version": "1.14.3", + "resolved": "https://registry.npmjs.org/@grpc/grpc-js/-/grpc-js-1.14.3.tgz", + "integrity": "sha512-Iq8QQQ/7X3Sac15oB6p0FmUg/klxQvXLeileoqrTRGJYLV+/9tubbr9ipz0GKHjmXVsgFPo/+W+2cA8eNcR+XA==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "@grpc/proto-loader": "^0.8.0", + "@js-sdsl/ordered-map": "^4.4.2" + }, + "engines": { + "node": ">=12.10.0" + } + }, + "node_modules/@grpc/grpc-js/node_modules/@grpc/proto-loader": { + "version": "0.8.0", + "resolved": "https://registry.npmjs.org/@grpc/proto-loader/-/proto-loader-0.8.0.tgz", + "integrity": "sha512-rc1hOQtjIWGxcxpb9aHAfLpIctjEnsDehj0DAiVfBlmT84uvR0uUtN2hEi/ecvWVjXUGf5qPF4qEgiLOx1YIMQ==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "lodash.camelcase": "^4.3.0", + "long": "^5.0.0", + "protobufjs": "^7.5.3", + "yargs": "^17.7.2" + }, + "bin": { + "proto-loader-gen-types": "build/bin/proto-loader-gen-types.js" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/@grpc/proto-loader": { + "version": "0.7.15", + "resolved": "https://registry.npmjs.org/@grpc/proto-loader/-/proto-loader-0.7.15.tgz", + "integrity": "sha512-tMXdRCfYVixjuFK+Hk0Q1s38gV9zDiDJfWL3h1rv4Qc39oILCu1TRTDt7+fGUI8K4G1Fj125Hx/ru3azECWTyQ==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "lodash.camelcase": "^4.3.0", + "long": "^5.0.0", + "protobufjs": "^7.2.5", + "yargs": "^17.7.2" + }, + "bin": { + "proto-loader-gen-types": "build/bin/proto-loader-gen-types.js" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/@js-sdsl/ordered-map": { + "version": "4.4.2", + "resolved": "https://registry.npmjs.org/@js-sdsl/ordered-map/-/ordered-map-4.4.2.tgz", + "integrity": "sha512-iUKgm52T8HOE/makSxjqoWhe95ZJA1/G1sYsGev2JDKUSS14KAgg1LHb+Ba+IPow0xflbnSkOsZcO08C7w1gYw==", + "license": "MIT", + "optional": true, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/js-sdsl" + } + }, + "node_modules/@noble/hashes": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.8.0.tgz", + "integrity": "sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^14.21.3 || >=16" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + } + }, + "node_modules/@opentelemetry/api": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/@opentelemetry/api/-/api-1.9.0.tgz", + "integrity": "sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg==", + "license": "Apache-2.0", + "optional": true, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/@paralleldrive/cuid2": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/@paralleldrive/cuid2/-/cuid2-2.3.1.tgz", + "integrity": "sha512-XO7cAxhnTZl0Yggq6jOgjiOHhbgcO4NqFqwSmQpjK3b6TEE6Uj/jfSk6wzYyemh3+I0sHirKSetjQwn5cZktFw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@noble/hashes": "^1.1.5" + } + }, + "node_modules/@pinojs/redact": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/@pinojs/redact/-/redact-0.4.0.tgz", + "integrity": "sha512-k2ENnmBugE/rzQfEcdWHcCY+/FM3VLzH9cYEsbdsoqrvzAKRhUZeRNhAZvB8OitQJ1TBed3yqWtdjzS6wJKBwg==", + "license": "MIT" + }, + "node_modules/@protobufjs/aspromise": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@protobufjs/aspromise/-/aspromise-1.1.2.tgz", + "integrity": "sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==", + "license": "BSD-3-Clause", + "optional": true + }, + "node_modules/@protobufjs/base64": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@protobufjs/base64/-/base64-1.1.2.tgz", + "integrity": "sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==", + "license": "BSD-3-Clause", + "optional": true + }, + "node_modules/@protobufjs/codegen": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/@protobufjs/codegen/-/codegen-2.0.4.tgz", + "integrity": "sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg==", + "license": "BSD-3-Clause", + "optional": true + }, + "node_modules/@protobufjs/eventemitter": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@protobufjs/eventemitter/-/eventemitter-1.1.0.tgz", + "integrity": "sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q==", + "license": "BSD-3-Clause", + "optional": true + }, + "node_modules/@protobufjs/fetch": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@protobufjs/fetch/-/fetch-1.1.0.tgz", + "integrity": "sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==", + "license": "BSD-3-Clause", + "optional": true, + "dependencies": { + "@protobufjs/aspromise": "^1.1.1", + "@protobufjs/inquire": "^1.1.0" + } + }, + "node_modules/@protobufjs/float": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@protobufjs/float/-/float-1.0.2.tgz", + "integrity": "sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==", + "license": "BSD-3-Clause", + "optional": true + }, + "node_modules/@protobufjs/inquire": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@protobufjs/inquire/-/inquire-1.1.0.tgz", + "integrity": "sha512-kdSefcPdruJiFMVSbn801t4vFK7KB/5gd2fYvrxhuJYg8ILrmn9SKSX2tZdV6V+ksulWqS7aXjBcRXl3wHoD9Q==", + "license": "BSD-3-Clause", + "optional": true + }, + "node_modules/@protobufjs/path": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@protobufjs/path/-/path-1.1.2.tgz", + "integrity": "sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==", + "license": "BSD-3-Clause", + "optional": true + }, + "node_modules/@protobufjs/pool": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@protobufjs/pool/-/pool-1.1.0.tgz", + "integrity": "sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==", + "license": "BSD-3-Clause", + "optional": true + }, + "node_modules/@protobufjs/utf8": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@protobufjs/utf8/-/utf8-1.1.0.tgz", + "integrity": "sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw==", + "license": "BSD-3-Clause", + "optional": true + }, + "node_modules/@tootallnate/once": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/@tootallnate/once/-/once-2.0.0.tgz", + "integrity": "sha512-XCuKFP5PS55gnMVu3dty8KPatLqUoy/ZYzDzAGCQ8JNFCkLXzmI7vNHCR+XpbZaMWQK/vQubr7PkYq8g470J/A==", + "license": "MIT", + "optional": true, + "engines": { + "node": ">= 10" + } + }, + "node_modules/@types/caseless": { + "version": "0.12.5", + "resolved": "https://registry.npmjs.org/@types/caseless/-/caseless-0.12.5.tgz", + "integrity": "sha512-hWtVTC2q7hc7xZ/RLbxapMvDMgUnDvKvMOpKal4DrMyfGBUfB1oKaZlIRr6mJL+If3bAP6sV/QneGzF6tJjZDg==", + "license": "MIT", + "optional": true + }, + "node_modules/@types/jsonwebtoken": { + "version": "9.0.10", + "resolved": "https://registry.npmjs.org/@types/jsonwebtoken/-/jsonwebtoken-9.0.10.tgz", + "integrity": "sha512-asx5hIG9Qmf/1oStypjanR7iKTv0gXQ1Ov/jfrX6kS/EO0OFni8orbmGCn0672NHR3kXHwpAwR+B368ZGN/2rA==", + "license": "MIT", + "dependencies": { + "@types/ms": "*", + "@types/node": "*" + } + }, + "node_modules/@types/long": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@types/long/-/long-4.0.2.tgz", + "integrity": "sha512-MqTGEo5bj5t157U6fA/BiDynNkn0YknVdh48CMPkTSpFTVmvao5UQmm7uEF6xBEo7qIMAlY/JSleYaE6VOdpaA==", + "license": "MIT", + "optional": true + }, + "node_modules/@types/ms": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/@types/ms/-/ms-2.1.0.tgz", + "integrity": "sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==", + "license": "MIT" + }, + "node_modules/@types/node": { + "version": "22.19.12", + "resolved": "https://registry.npmjs.org/@types/node/-/node-22.19.12.tgz", + "integrity": "sha512-0QEp0aPJYSyf6RrTjDB7HlKgNMTY+V2C7ESTaVt6G9gQ0rPLzTGz7OF2NXTLR5vcy7HJEtIUsyWLsfX0kTqJBA==", + "license": "MIT", + "dependencies": { + "undici-types": "~6.21.0" + } + }, + "node_modules/@types/request": { + "version": "2.48.13", + "resolved": "https://registry.npmjs.org/@types/request/-/request-2.48.13.tgz", + "integrity": "sha512-FGJ6udDNUCjd19pp0Q3iTiDkwhYup7J8hpMW9c4k53NrccQFFWKRho6hvtPPEhnXWKvukfwAlB6DbDz4yhH5Gg==", + "license": "MIT", + "optional": true, + "dependencies": { + "@types/caseless": "*", + "@types/node": "*", + "@types/tough-cookie": "*", + "form-data": "^2.5.5" + } + }, + "node_modules/@types/tough-cookie": { + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/@types/tough-cookie/-/tough-cookie-4.0.5.tgz", + "integrity": "sha512-/Ad8+nIOV7Rl++6f1BdKxFSMgmoqEoYbHRpPcx3JEfv8VRsQe9Z4mCXeJBzxs7mbHY/XOZZuXlRNfhpVPbs6ZA==", + "license": "MIT", + "optional": true + }, + "node_modules/abort-controller": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/abort-controller/-/abort-controller-3.0.0.tgz", + "integrity": "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==", + "license": "MIT", + "optional": true, + "dependencies": { + "event-target-shim": "^5.0.0" + }, + "engines": { + "node": ">=6.5" + } + }, + "node_modules/accepts": { + "version": "1.3.8", + "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz", + "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==", + "license": "MIT", + "dependencies": { + "mime-types": "~2.1.34", + "negotiator": "0.6.3" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/agent-base": { + "version": "7.1.4", + "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz", + "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==", + "license": "MIT", + "engines": { + "node": ">= 14" + } + }, + "node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "license": "MIT", + "optional": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "license": "MIT", + "optional": true, + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/array-flatten": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz", + "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==", + "license": "MIT" + }, + "node_modules/arrify": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/arrify/-/arrify-2.0.1.tgz", + "integrity": "sha512-3duEwti880xqi4eAMN8AyR4a0ByT90zoYdLlevfrvU43vb0YZwZVfxOgxWrLXXXpyugL0hNZc9G6BiB5B3nUug==", + "license": "MIT", + "optional": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/asap": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/asap/-/asap-2.0.6.tgz", + "integrity": "sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA==", + "dev": true, + "license": "MIT" + }, + "node_modules/async-retry": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/async-retry/-/async-retry-1.3.3.tgz", + "integrity": "sha512-wfr/jstw9xNi/0teMHrRW7dsz3Lt5ARhYNZ2ewpadnhaIp5mbALhOAP+EAdsC7t4Z6wqsDVv9+W6gm1Dk9mEyw==", + "license": "MIT", + "optional": true, + "dependencies": { + "retry": "0.13.1" + } + }, + "node_modules/asynckit": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", + "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==", + "devOptional": true, + "license": "MIT" + }, + "node_modules/atomic-sleep": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/atomic-sleep/-/atomic-sleep-1.0.0.tgz", + "integrity": "sha512-kNOjDqAh7px0XWNI+4QbzoiR/nTkHAWNud2uvnJquD1/x5a7EQZMJT0AczqK0Qn67oY/TTQ1LbUKajZpp3I9tQ==", + "license": "MIT", + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/base64-js": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz", + "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/bignumber.js": { + "version": "9.3.1", + "resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-9.3.1.tgz", + "integrity": "sha512-Ko0uX15oIUS7wJ3Rb30Fs6SkVbLmPBAKdlm7q9+ak9bbIeFf0MwuBsQV6z7+X768/cHsfg+WlysDWJcmthjsjQ==", + "license": "MIT", + "engines": { + "node": "*" + } + }, + "node_modules/body-parser": { + "version": "1.20.4", + "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.4.tgz", + "integrity": "sha512-ZTgYYLMOXY9qKU/57FAo8F+HA2dGX7bqGc71txDRC1rS4frdFI5R7NhluHxH6M0YItAP0sHB4uqAOcYKxO6uGA==", + "license": "MIT", + "dependencies": { + "bytes": "~3.1.2", + "content-type": "~1.0.5", + "debug": "2.6.9", + "depd": "2.0.0", + "destroy": "~1.2.0", + "http-errors": "~2.0.1", + "iconv-lite": "~0.4.24", + "on-finished": "~2.4.1", + "qs": "~6.14.0", + "raw-body": "~2.5.3", + "type-is": "~1.6.18", + "unpipe": "~1.0.0" + }, + "engines": { + "node": ">= 0.8", + "npm": "1.2.8000 || >= 1.4.16" + } + }, + "node_modules/buffer-equal-constant-time": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/buffer-equal-constant-time/-/buffer-equal-constant-time-1.0.1.tgz", + "integrity": "sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA==", + "license": "BSD-3-Clause" + }, + "node_modules/bytes": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", + "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/call-bind-apply-helpers": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz", + "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/call-bound": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz", + "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "get-intrinsic": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/cliui": { + "version": "8.0.1", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz", + "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==", + "license": "ISC", + "optional": true, + "dependencies": { + "string-width": "^4.2.0", + "strip-ansi": "^6.0.1", + "wrap-ansi": "^7.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "license": "MIT", + "optional": true, + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "license": "MIT", + "optional": true + }, + "node_modules/combined-stream": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz", + "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==", + "devOptional": true, + "license": "MIT", + "dependencies": { + "delayed-stream": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/component-emitter": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/component-emitter/-/component-emitter-1.3.1.tgz", + "integrity": "sha512-T0+barUSQRTUQASh8bx02dl+DhF54GtIDY13Y3m9oWTklKbb3Wv974meRpeZ3lp1JpLVECWWNHC4vaG2XHXouQ==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/content-disposition": { + "version": "0.5.4", + "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz", + "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==", + "license": "MIT", + "dependencies": { + "safe-buffer": "5.2.1" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/content-type": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz", + "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/cookie": { + "version": "0.7.2", + "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.2.tgz", + "integrity": "sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/cookie-signature": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.7.tgz", + "integrity": "sha512-NXdYc3dLr47pBkpUCHtKSwIOQXLVn8dZEuywboCOJY/osA0wFSLlSawr3KN8qXJEyX66FcONTH8EIlVuK0yyFA==", + "license": "MIT" + }, + "node_modules/cookiejar": { + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/cookiejar/-/cookiejar-2.1.4.tgz", + "integrity": "sha512-LDx6oHrK+PhzLKJU9j5S7/Y3jM/mUHvD/DeI1WQmJn652iPC5Y4TBzC9l+5OMOXlyTTA+SmVUPm0HQUwpD5Jqw==", + "dev": true, + "license": "MIT" + }, + "node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "license": "MIT", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/delayed-stream": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", + "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==", + "devOptional": true, + "license": "MIT", + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/depd": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", + "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/destroy": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz", + "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==", + "license": "MIT", + "engines": { + "node": ">= 0.8", + "npm": "1.2.8000 || >= 1.4.16" + } + }, + "node_modules/dezalgo": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/dezalgo/-/dezalgo-1.0.4.tgz", + "integrity": "sha512-rXSP0bf+5n0Qonsb+SVVfNfIsimO4HEtmnIpPHY8Q1UCzKlQrDMfdobr8nJOOsRgWCyMRqeSBQzmWUMq7zvVig==", + "dev": true, + "license": "ISC", + "dependencies": { + "asap": "^2.0.0", + "wrappy": "1" + } + }, + "node_modules/dunder-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz", + "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.1", + "es-errors": "^1.3.0", + "gopd": "^1.2.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/duplexify": { + "version": "4.1.3", + "resolved": "https://registry.npmjs.org/duplexify/-/duplexify-4.1.3.tgz", + "integrity": "sha512-M3BmBhwJRZsSx38lZyhE53Csddgzl5R7xGJNk7CVddZD6CcmwMCH8J+7AprIrQKH7TonKxaCjcv27Qmf+sQ+oA==", + "license": "MIT", + "optional": true, + "dependencies": { + "end-of-stream": "^1.4.1", + "inherits": "^2.0.3", + "readable-stream": "^3.1.1", + "stream-shift": "^1.0.2" + } + }, + "node_modules/ecdsa-sig-formatter": { + "version": "1.0.11", + "resolved": "https://registry.npmjs.org/ecdsa-sig-formatter/-/ecdsa-sig-formatter-1.0.11.tgz", + "integrity": "sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==", + "license": "Apache-2.0", + "dependencies": { + "safe-buffer": "^5.0.1" + } + }, + "node_modules/ee-first": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz", + "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==", + "license": "MIT" + }, + "node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "license": "MIT", + "optional": true + }, + "node_modules/encodeurl": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", + "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/end-of-stream": { + "version": "1.4.5", + "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.5.tgz", + "integrity": "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==", + "license": "MIT", + "optional": true, + "dependencies": { + "once": "^1.4.0" + } + }, + "node_modules/es-define-property": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz", + "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-errors": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz", + "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-object-atoms": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz", + "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-set-tostringtag": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz", + "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==", + "devOptional": true, + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.6", + "has-tostringtag": "^1.0.2", + "hasown": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/escalade": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz", + "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==", + "license": "MIT", + "optional": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/escape-html": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz", + "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==", + "license": "MIT" + }, + "node_modules/etag": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz", + "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/event-target-shim": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/event-target-shim/-/event-target-shim-5.0.1.tgz", + "integrity": "sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==", + "license": "MIT", + "optional": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/express": { + "version": "4.22.1", + "resolved": "https://registry.npmjs.org/express/-/express-4.22.1.tgz", + "integrity": "sha512-F2X8g9P1X7uCPZMA3MVf9wcTqlyNp7IhH5qPCI0izhaOIYXaW9L535tGA3qmjRzpH+bZczqq7hVKxTR4NWnu+g==", + "license": "MIT", + "dependencies": { + "accepts": "~1.3.8", + "array-flatten": "1.1.1", + "body-parser": "~1.20.3", + "content-disposition": "~0.5.4", + "content-type": "~1.0.4", + "cookie": "~0.7.1", + "cookie-signature": "~1.0.6", + "debug": "2.6.9", + "depd": "2.0.0", + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "finalhandler": "~1.3.1", + "fresh": "~0.5.2", + "http-errors": "~2.0.0", + "merge-descriptors": "1.0.3", + "methods": "~1.1.2", + "on-finished": "~2.4.1", + "parseurl": "~1.3.3", + "path-to-regexp": "~0.1.12", + "proxy-addr": "~2.0.7", + "qs": "~6.14.0", + "range-parser": "~1.2.1", + "safe-buffer": "5.2.1", + "send": "~0.19.0", + "serve-static": "~1.16.2", + "setprototypeof": "1.2.0", + "statuses": "~2.0.1", + "type-is": "~1.6.18", + "utils-merge": "1.0.1", + "vary": "~1.1.2" + }, + "engines": { + "node": ">= 0.10.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/extend": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz", + "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==", + "license": "MIT" + }, + "node_modules/farmhash-modern": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/farmhash-modern/-/farmhash-modern-1.1.0.tgz", + "integrity": "sha512-6ypT4XfgqJk/F3Yuv4SX26I3doUjt0GTG4a+JgWxXQpxXzTBq8fPUeGHfcYMMDPHJHm3yPOSjaeBwBGAHWXCdA==", + "license": "MIT", + "engines": { + "node": ">=18.0.0" + } + }, + "node_modules/fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "license": "MIT" + }, + "node_modules/fast-safe-stringify": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/fast-safe-stringify/-/fast-safe-stringify-2.1.1.tgz", + "integrity": "sha512-W+KJc2dmILlPplD/H4K9l9LcAHAfPtP6BY84uVLXQ6Evcz9Lcg33Y2z1IVblT6xdY54PXYVHEv+0Wpq8Io6zkA==", + "dev": true, + "license": "MIT" + }, + "node_modules/fast-xml-builder": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fast-xml-builder/-/fast-xml-builder-1.0.0.tgz", + "integrity": "sha512-fpZuDogrAgnyt9oDDz+5DBz0zgPdPZz6D4IR7iESxRXElrlGTRkHJ9eEt+SACRJwT0FNFrt71DFQIUFBJfX/uQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/NaturalIntelligence" + } + ], + "license": "MIT", + "optional": true + }, + "node_modules/fast-xml-parser": { + "version": "5.4.1", + "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.4.1.tgz", + "integrity": "sha512-BQ30U1mKkvXQXXkAGcuyUA/GA26oEB7NzOtsxCDtyu62sjGw5QraKFhx2Em3WQNjPw9PG6MQ9yuIIgkSDfGu5A==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/NaturalIntelligence" + } + ], + "license": "MIT", + "optional": true, + "dependencies": { + "fast-xml-builder": "^1.0.0", + "strnum": "^2.1.2" + }, + "bin": { + "fxparser": "src/cli/cli.js" + } + }, + "node_modules/faye-websocket": { + "version": "0.11.4", + "resolved": "https://registry.npmjs.org/faye-websocket/-/faye-websocket-0.11.4.tgz", + "integrity": "sha512-CzbClwlXAuiRQAlUyfqPgvPoNKTckTPGfwZV4ZdAhVcP2lh9KUxJg2b5GkE7XbjKQ3YJnQ9z6D9ntLAlB+tP8g==", + "license": "Apache-2.0", + "dependencies": { + "websocket-driver": ">=0.5.1" + }, + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/finalhandler": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.2.tgz", + "integrity": "sha512-aA4RyPcd3badbdABGDuTXCMTtOneUCAYH/gxoYRTZlIJdF0YPWuGqiAsIrhNnnqdXGswYk6dGujem4w80UJFhg==", + "license": "MIT", + "dependencies": { + "debug": "2.6.9", + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "on-finished": "~2.4.1", + "parseurl": "~1.3.3", + "statuses": "~2.0.2", + "unpipe": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/firebase-admin": { + "version": "13.6.1", + "resolved": "https://registry.npmjs.org/firebase-admin/-/firebase-admin-13.6.1.tgz", + "integrity": "sha512-Zgc6yPtmPxAZo+FoK6LMG6zpSEsoSK8ifIR+IqF4oWuC3uWZU40OjxgfLTSFcsRlj/k/wD66zNv2UiTRreCNSw==", + "license": "Apache-2.0", + "dependencies": { + "@fastify/busboy": "^3.0.0", + "@firebase/database-compat": "^2.0.0", + "@firebase/database-types": "^1.0.6", + "@types/node": "^22.8.7", + "farmhash-modern": "^1.1.0", + "fast-deep-equal": "^3.1.1", + "google-auth-library": "^9.14.2", + "jsonwebtoken": "^9.0.0", + "jwks-rsa": "^3.1.0", + "node-forge": "^1.3.1", + "uuid": "^11.0.2" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "@google-cloud/firestore": "^7.11.0", + "@google-cloud/storage": "^7.14.0" + } + }, + "node_modules/form-data": { + "version": "2.5.5", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-2.5.5.tgz", + "integrity": "sha512-jqdObeR2rxZZbPSGL+3VckHMYtu+f9//KXBsVny6JSX/pa38Fy+bGjuG8eW/H6USNQWhLi8Num++cU2yOCNz4A==", + "license": "MIT", + "optional": true, + "dependencies": { + "asynckit": "^0.4.0", + "combined-stream": "^1.0.8", + "es-set-tostringtag": "^2.1.0", + "hasown": "^2.0.2", + "mime-types": "^2.1.35", + "safe-buffer": "^5.2.1" + }, + "engines": { + "node": ">= 0.12" + } + }, + "node_modules/formidable": { + "version": "3.5.4", + "resolved": "https://registry.npmjs.org/formidable/-/formidable-3.5.4.tgz", + "integrity": "sha512-YikH+7CUTOtP44ZTnUhR7Ic2UASBPOqmaRkRKxRbywPTe5VxF7RRCck4af9wutiZ/QKM5nME9Bie2fFaPz5Gug==", + "dev": true, + "license": "MIT", + "dependencies": { + "@paralleldrive/cuid2": "^2.2.2", + "dezalgo": "^1.0.4", + "once": "^1.4.0" + }, + "engines": { + "node": ">=14.0.0" + }, + "funding": { + "url": "https://ko-fi.com/tunnckoCore/commissions" + } + }, + "node_modules/forwarded": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz", + "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/fresh": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz", + "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/function-bind": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", + "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/functional-red-black-tree": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz", + "integrity": "sha512-dsKNQNdj6xA3T+QlADDA7mOSlX0qiMINjn0cgr+eGHGsbSHzTabcIogz2+p/iqP1Xs6EP/sS2SbqH+brGTbq0g==", + "license": "MIT", + "optional": true + }, + "node_modules/gaxios": { + "version": "6.7.1", + "resolved": "https://registry.npmjs.org/gaxios/-/gaxios-6.7.1.tgz", + "integrity": "sha512-LDODD4TMYx7XXdpwxAVRAIAuB0bzv0s+ywFonY46k126qzQHT9ygyoa9tncmOiQmmDrik65UYsEkv3lbfqQ3yQ==", + "license": "Apache-2.0", + "dependencies": { + "extend": "^3.0.2", + "https-proxy-agent": "^7.0.1", + "is-stream": "^2.0.0", + "node-fetch": "^2.6.9", + "uuid": "^9.0.1" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/gaxios/node_modules/uuid": { + "version": "9.0.1", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-9.0.1.tgz", + "integrity": "sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA==", + "funding": [ + "https://github.com/sponsors/broofa", + "https://github.com/sponsors/ctavan" + ], + "license": "MIT", + "bin": { + "uuid": "dist/bin/uuid" + } + }, + "node_modules/gcp-metadata": { + "version": "6.1.1", + "resolved": "https://registry.npmjs.org/gcp-metadata/-/gcp-metadata-6.1.1.tgz", + "integrity": "sha512-a4tiq7E0/5fTjxPAaH4jpjkSv/uCaU2p5KC6HVGrvl0cDjA8iBZv4vv1gyzlmK0ZUKqwpOyQMKzZQe3lTit77A==", + "license": "Apache-2.0", + "dependencies": { + "gaxios": "^6.1.1", + "google-logging-utils": "^0.0.2", + "json-bigint": "^1.0.0" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/get-caller-file": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", + "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", + "license": "ISC", + "engines": { + "node": "6.* || 8.* || >= 10.*" + } + }, + "node_modules/get-intrinsic": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz", + "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "es-define-property": "^1.0.1", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.1.1", + "function-bind": "^1.1.2", + "get-proto": "^1.0.1", + "gopd": "^1.2.0", + "has-symbols": "^1.1.0", + "hasown": "^2.0.2", + "math-intrinsics": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz", + "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==", + "license": "MIT", + "dependencies": { + "dunder-proto": "^1.0.1", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/google-auth-library": { + "version": "9.15.1", + "resolved": "https://registry.npmjs.org/google-auth-library/-/google-auth-library-9.15.1.tgz", + "integrity": "sha512-Jb6Z0+nvECVz+2lzSMt9u98UsoakXxA2HGHMCxh+so3n90XgYWkq5dur19JAJV7ONiJY22yBTyJB1TSkvPq9Ng==", + "license": "Apache-2.0", + "dependencies": { + "base64-js": "^1.3.0", + "ecdsa-sig-formatter": "^1.0.11", + "gaxios": "^6.1.1", + "gcp-metadata": "^6.1.0", + "gtoken": "^7.0.0", + "jws": "^4.0.0" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/google-gax": { + "version": "4.6.1", + "resolved": "https://registry.npmjs.org/google-gax/-/google-gax-4.6.1.tgz", + "integrity": "sha512-V6eky/xz2mcKfAd1Ioxyd6nmA61gao3n01C+YeuIwu3vzM9EDR6wcVzMSIbLMDXWeoi9SHYctXuKYC5uJUT3eQ==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "@grpc/grpc-js": "^1.10.9", + "@grpc/proto-loader": "^0.7.13", + "@types/long": "^4.0.0", + "abort-controller": "^3.0.0", + "duplexify": "^4.0.0", + "google-auth-library": "^9.3.0", + "node-fetch": "^2.7.0", + "object-hash": "^3.0.0", + "proto3-json-serializer": "^2.0.2", + "protobufjs": "^7.3.2", + "retry-request": "^7.0.0", + "uuid": "^9.0.1" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/google-gax/node_modules/uuid": { + "version": "9.0.1", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-9.0.1.tgz", + "integrity": "sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA==", + "funding": [ + "https://github.com/sponsors/broofa", + "https://github.com/sponsors/ctavan" + ], + "license": "MIT", + "optional": true, + "bin": { + "uuid": "dist/bin/uuid" + } + }, + "node_modules/google-logging-utils": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/google-logging-utils/-/google-logging-utils-0.0.2.tgz", + "integrity": "sha512-NEgUnEcBiP5HrPzufUkBzJOD/Sxsco3rLNo1F1TNf7ieU8ryUzBhqba8r756CjLX7rn3fHl6iLEwPYuqpoKgQQ==", + "license": "Apache-2.0", + "engines": { + "node": ">=14" + } + }, + "node_modules/gopd": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz", + "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/gtoken": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/gtoken/-/gtoken-7.1.0.tgz", + "integrity": "sha512-pCcEwRi+TKpMlxAQObHDQ56KawURgyAf6jtIY046fJ5tIv3zDe/LEIubckAO8fj6JnAxLdmWkUfNyulQ2iKdEw==", + "license": "MIT", + "dependencies": { + "gaxios": "^6.0.0", + "jws": "^4.0.0" + }, + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/has-symbols": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz", + "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-tostringtag": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz", + "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==", + "devOptional": true, + "license": "MIT", + "dependencies": { + "has-symbols": "^1.0.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/hasown": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz", + "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==", + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/html-entities": { + "version": "2.6.0", + "resolved": "https://registry.npmjs.org/html-entities/-/html-entities-2.6.0.tgz", + "integrity": "sha512-kig+rMn/QOVRvr7c86gQ8lWXq+Hkv6CbAH1hLu+RG338StTpE8Z0b44SDVaqVu7HGKf27frdmUYEs9hTUX/cLQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/mdevils" + }, + { + "type": "patreon", + "url": "https://patreon.com/mdevils" + } + ], + "license": "MIT", + "optional": true + }, + "node_modules/http-errors": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz", + "integrity": "sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==", + "license": "MIT", + "dependencies": { + "depd": "~2.0.0", + "inherits": "~2.0.4", + "setprototypeof": "~1.2.0", + "statuses": "~2.0.2", + "toidentifier": "~1.0.1" + }, + "engines": { + "node": ">= 0.8" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/http-parser-js": { + "version": "0.5.10", + "resolved": "https://registry.npmjs.org/http-parser-js/-/http-parser-js-0.5.10.tgz", + "integrity": "sha512-Pysuw9XpUq5dVc/2SMHpuTY01RFl8fttgcyunjL7eEMhGM3cI4eOmiCycJDVCo/7O7ClfQD3SaI6ftDzqOXYMA==", + "license": "MIT" + }, + "node_modules/http-proxy-agent": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-5.0.0.tgz", + "integrity": "sha512-n2hY8YdoRE1i7r6M0w9DIw5GgZN0G25P8zLCRQ8rjXtTU3vsNFBI/vWK/UIeE6g5MUUz6avwAPXmL6Fy9D/90w==", + "license": "MIT", + "optional": true, + "dependencies": { + "@tootallnate/once": "2", + "agent-base": "6", + "debug": "4" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/http-proxy-agent/node_modules/agent-base": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz", + "integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==", + "license": "MIT", + "optional": true, + "dependencies": { + "debug": "4" + }, + "engines": { + "node": ">= 6.0.0" + } + }, + "node_modules/http-proxy-agent/node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "license": "MIT", + "optional": true, + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/http-proxy-agent/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "license": "MIT", + "optional": true + }, + "node_modules/https-proxy-agent": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz", + "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==", + "license": "MIT", + "dependencies": { + "agent-base": "^7.1.2", + "debug": "4" + }, + "engines": { + "node": ">= 14" + } + }, + "node_modules/https-proxy-agent/node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/https-proxy-agent/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "license": "MIT" + }, + "node_modules/iconv-lite": { + "version": "0.4.24", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", + "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", + "license": "MIT", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "license": "ISC" + }, + "node_modules/ipaddr.js": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz", + "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==", + "license": "MIT", + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "license": "MIT", + "optional": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/is-stream": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz", + "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==", + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/jose": { + "version": "4.15.9", + "resolved": "https://registry.npmjs.org/jose/-/jose-4.15.9.tgz", + "integrity": "sha512-1vUQX+IdDMVPj4k8kOxgUqlcK518yluMuGZwqlr44FS1ppZB/5GWh4rZG89erpOBOJjU/OBsnCVFfapsRz6nEA==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/panva" + } + }, + "node_modules/json-bigint": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-bigint/-/json-bigint-1.0.0.tgz", + "integrity": "sha512-SiPv/8VpZuWbvLSMtTDU8hEfrZWg/mH/nV/b4o0CYbSxu1UIQPLdwKOCIyLQX+VIPO5vrLX3i8qtqFyhdPSUSQ==", + "license": "MIT", + "dependencies": { + "bignumber.js": "^9.0.0" + } + }, + "node_modules/jsonwebtoken": { + "version": "9.0.3", + "resolved": "https://registry.npmjs.org/jsonwebtoken/-/jsonwebtoken-9.0.3.tgz", + "integrity": "sha512-MT/xP0CrubFRNLNKvxJ2BYfy53Zkm++5bX9dtuPbqAeQpTVe0MQTFhao8+Cp//EmJp244xt6Drw/GVEGCUj40g==", + "license": "MIT", + "dependencies": { + "jws": "^4.0.1", + "lodash.includes": "^4.3.0", + "lodash.isboolean": "^3.0.3", + "lodash.isinteger": "^4.0.4", + "lodash.isnumber": "^3.0.3", + "lodash.isplainobject": "^4.0.6", + "lodash.isstring": "^4.0.1", + "lodash.once": "^4.0.0", + "ms": "^2.1.1", + "semver": "^7.5.4" + }, + "engines": { + "node": ">=12", + "npm": ">=6" + } + }, + "node_modules/jsonwebtoken/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "license": "MIT" + }, + "node_modules/jwa": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/jwa/-/jwa-2.0.1.tgz", + "integrity": "sha512-hRF04fqJIP8Abbkq5NKGN0Bbr3JxlQ+qhZufXVr0DvujKy93ZCbXZMHDL4EOtodSbCWxOqR8MS1tXA5hwqCXDg==", + "license": "MIT", + "dependencies": { + "buffer-equal-constant-time": "^1.0.1", + "ecdsa-sig-formatter": "1.0.11", + "safe-buffer": "^5.0.1" + } + }, + "node_modules/jwks-rsa": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/jwks-rsa/-/jwks-rsa-3.2.2.tgz", + "integrity": "sha512-BqTyEDV+lS8F2trk3A+qJnxV5Q9EqKCBJOPti3W97r7qTympCZjb7h2X6f2kc+0K3rsSTY1/6YG2eaXKoj497w==", + "license": "MIT", + "dependencies": { + "@types/jsonwebtoken": "^9.0.4", + "debug": "^4.3.4", + "jose": "^4.15.4", + "limiter": "^1.1.5", + "lru-memoizer": "^2.2.0" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/jwks-rsa/node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/jwks-rsa/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "license": "MIT" + }, + "node_modules/jws": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/jws/-/jws-4.0.1.tgz", + "integrity": "sha512-EKI/M/yqPncGUUh44xz0PxSidXFr/+r0pA70+gIYhjv+et7yxM+s29Y+VGDkovRofQem0fs7Uvf4+YmAdyRduA==", + "license": "MIT", + "dependencies": { + "jwa": "^2.0.1", + "safe-buffer": "^5.0.1" + } + }, + "node_modules/limiter": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/limiter/-/limiter-1.1.5.tgz", + "integrity": "sha512-FWWMIEOxz3GwUI4Ts/IvgVy6LPvoMPgjMdQ185nN6psJyBJ4yOpzqm695/h5umdLJg2vW3GR5iG11MAkR2AzJA==" + }, + "node_modules/lodash.camelcase": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz", + "integrity": "sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA==", + "license": "MIT", + "optional": true + }, + "node_modules/lodash.clonedeep": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/lodash.clonedeep/-/lodash.clonedeep-4.5.0.tgz", + "integrity": "sha512-H5ZhCF25riFd9uB5UCkVKo61m3S/xZk1x4wA6yp/L3RFP6Z/eHH1ymQcGLo7J3GMPfm0V/7m1tryHuGVxpqEBQ==", + "license": "MIT" + }, + "node_modules/lodash.includes": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/lodash.includes/-/lodash.includes-4.3.0.tgz", + "integrity": "sha512-W3Bx6mdkRTGtlJISOvVD/lbqjTlPPUDTMnlXZFnVwi9NKJ6tiAk6LVdlhZMm17VZisqhKcgzpO5Wz91PCt5b0w==", + "license": "MIT" + }, + "node_modules/lodash.isboolean": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/lodash.isboolean/-/lodash.isboolean-3.0.3.tgz", + "integrity": "sha512-Bz5mupy2SVbPHURB98VAcw+aHh4vRV5IPNhILUCsOzRmsTmSQ17jIuqopAentWoehktxGd9e/hbIXq980/1QJg==", + "license": "MIT" + }, + "node_modules/lodash.isinteger": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/lodash.isinteger/-/lodash.isinteger-4.0.4.tgz", + "integrity": "sha512-DBwtEWN2caHQ9/imiNeEA5ys1JoRtRfY3d7V9wkqtbycnAmTvRRmbHKDV4a0EYc678/dia0jrte4tjYwVBaZUA==", + "license": "MIT" + }, + "node_modules/lodash.isnumber": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/lodash.isnumber/-/lodash.isnumber-3.0.3.tgz", + "integrity": "sha512-QYqzpfwO3/CWf3XP+Z+tkQsfaLL/EnUlXWVkIk5FUPc4sBdTehEqZONuyRt2P67PXAk+NXmTBcc97zw9t1FQrw==", + "license": "MIT" + }, + "node_modules/lodash.isplainobject": { + "version": "4.0.6", + "resolved": "https://registry.npmjs.org/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz", + "integrity": "sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==", + "license": "MIT" + }, + "node_modules/lodash.isstring": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/lodash.isstring/-/lodash.isstring-4.0.1.tgz", + "integrity": "sha512-0wJxfxH1wgO3GrbuP+dTTk7op+6L41QCXbGINEmD+ny/G/eCqGzxyCsh7159S+mgDDcoarnBw6PC1PS5+wUGgw==", + "license": "MIT" + }, + "node_modules/lodash.once": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/lodash.once/-/lodash.once-4.1.1.tgz", + "integrity": "sha512-Sb487aTOCr9drQVL8pIxOzVhafOjZN9UU54hiN8PU3uAiSV7lx1yYNpbNmex2PK6dSJoNTSJUUswT651yww3Mg==", + "license": "MIT" + }, + "node_modules/long": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/long/-/long-5.3.2.tgz", + "integrity": "sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==", + "license": "Apache-2.0", + "optional": true + }, + "node_modules/lru-cache": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", + "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", + "license": "ISC", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/lru-memoizer": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/lru-memoizer/-/lru-memoizer-2.3.0.tgz", + "integrity": "sha512-GXn7gyHAMhO13WSKrIiNfztwxodVsP8IoZ3XfrJV4yH2x0/OeTO/FIaAHTY5YekdGgW94njfuKmyyt1E0mR6Ug==", + "license": "MIT", + "dependencies": { + "lodash.clonedeep": "^4.5.0", + "lru-cache": "6.0.0" + } + }, + "node_modules/math-intrinsics": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz", + "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/media-typer": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz", + "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/merge-descriptors": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz", + "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/methods": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz", + "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/mime/-/mime-3.0.0.tgz", + "integrity": "sha512-jSCU7/VB1loIWBZe14aEYHU/+1UMEHoaO7qxCOVJOw9GgH72VAWppxNcjU+x9a2k3GSIBXNKxXQFqRvvZ7vr3A==", + "license": "MIT", + "optional": true, + "bin": { + "mime": "cli.js" + }, + "engines": { + "node": ">=10.0.0" + } + }, + "node_modules/mime-db": { + "version": "1.52.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz", + "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime-types": { + "version": "2.1.35", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz", + "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==", + "license": "MIT", + "dependencies": { + "mime-db": "1.52.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==", + "license": "MIT" + }, + "node_modules/negotiator": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz", + "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/node-fetch": { + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz", + "integrity": "sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==", + "license": "MIT", + "dependencies": { + "whatwg-url": "^5.0.0" + }, + "engines": { + "node": "4.x || >=6.0.0" + }, + "peerDependencies": { + "encoding": "^0.1.0" + }, + "peerDependenciesMeta": { + "encoding": { + "optional": true + } + } + }, + "node_modules/node-forge": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/node-forge/-/node-forge-1.3.3.tgz", + "integrity": "sha512-rLvcdSyRCyouf6jcOIPe/BgwG/d7hKjzMKOas33/pHEr6gbq18IK9zV7DiPvzsz0oBJPme6qr6H6kGZuI9/DZg==", + "license": "(BSD-3-Clause OR GPL-2.0)", + "engines": { + "node": ">= 6.13.0" + } + }, + "node_modules/object-hash": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/object-hash/-/object-hash-3.0.0.tgz", + "integrity": "sha512-RSn9F68PjH9HqtltsSnqYC1XXoWe9Bju5+213R98cNGttag9q9yAOTzdbsqvIa7aNm5WffBZFpWYr2aWrklWAw==", + "license": "MIT", + "optional": true, + "engines": { + "node": ">= 6" + } + }, + "node_modules/object-inspect": { + "version": "1.13.4", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz", + "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/on-exit-leak-free": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/on-exit-leak-free/-/on-exit-leak-free-2.1.2.tgz", + "integrity": "sha512-0eJJY6hXLGf1udHwfNftBqH+g73EU4B504nZeKpz1sYRKafAghwxEJunB2O7rDZkL4PGfsMVnTXZ2EjibbqcsA==", + "license": "MIT", + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/on-finished": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz", + "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==", + "license": "MIT", + "dependencies": { + "ee-first": "1.1.1" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "devOptional": true, + "license": "ISC", + "dependencies": { + "wrappy": "1" + } + }, + "node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "license": "MIT", + "optional": true, + "dependencies": { + "yocto-queue": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/parseurl": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz", + "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/path-to-regexp": { + "version": "0.1.12", + "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.12.tgz", + "integrity": "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==", + "license": "MIT" + }, + "node_modules/pino": { + "version": "9.14.0", + "resolved": "https://registry.npmjs.org/pino/-/pino-9.14.0.tgz", + "integrity": "sha512-8OEwKp5juEvb/MjpIc4hjqfgCNysrS94RIOMXYvpYCdm/jglrKEiAYmiumbmGhCvs+IcInsphYDFwqrjr7398w==", + "license": "MIT", + "dependencies": { + "@pinojs/redact": "^0.4.0", + "atomic-sleep": "^1.0.0", + "on-exit-leak-free": "^2.1.0", + "pino-abstract-transport": "^2.0.0", + "pino-std-serializers": "^7.0.0", + "process-warning": "^5.0.0", + "quick-format-unescaped": "^4.0.3", + "real-require": "^0.2.0", + "safe-stable-stringify": "^2.3.1", + "sonic-boom": "^4.0.1", + "thread-stream": "^3.0.0" + }, + "bin": { + "pino": "bin.js" + } + }, + "node_modules/pino-abstract-transport": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/pino-abstract-transport/-/pino-abstract-transport-2.0.0.tgz", + "integrity": "sha512-F63x5tizV6WCh4R6RHyi2Ml+M70DNRXt/+HANowMflpgGFMAym/VKm6G7ZOQRjqN7XbGxK1Lg9t6ZrtzOaivMw==", + "license": "MIT", + "dependencies": { + "split2": "^4.0.0" + } + }, + "node_modules/pino-http": { + "version": "10.5.0", + "resolved": "https://registry.npmjs.org/pino-http/-/pino-http-10.5.0.tgz", + "integrity": "sha512-hD91XjgaKkSsdn8P7LaebrNzhGTdB086W3pyPihX0EzGPjq5uBJBXo4N5guqNaK6mUjg9aubMF7wDViYek9dRA==", + "license": "MIT", + "dependencies": { + "get-caller-file": "^2.0.5", + "pino": "^9.0.0", + "pino-std-serializers": "^7.0.0", + "process-warning": "^5.0.0" + } + }, + "node_modules/pino-std-serializers": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/pino-std-serializers/-/pino-std-serializers-7.1.0.tgz", + "integrity": "sha512-BndPH67/JxGExRgiX1dX0w1FvZck5Wa4aal9198SrRhZjH3GxKQUKIBnYJTdj2HDN3UQAS06HlfcSbQj2OHmaw==", + "license": "MIT" + }, + "node_modules/process-warning": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/process-warning/-/process-warning-5.0.0.tgz", + "integrity": "sha512-a39t9ApHNx2L4+HBnQKqxxHNs1r7KF+Intd8Q/g1bUh6q0WIp9voPXJ/x0j+ZL45KF1pJd9+q2jLIRMfvEshkA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/fastify" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/fastify" + } + ], + "license": "MIT" + }, + "node_modules/proto3-json-serializer": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/proto3-json-serializer/-/proto3-json-serializer-2.0.2.tgz", + "integrity": "sha512-SAzp/O4Yh02jGdRc+uIrGoe87dkN/XtwxfZ4ZyafJHymd79ozp5VG5nyZ7ygqPM5+cpLDjjGnYFUkngonyDPOQ==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "protobufjs": "^7.2.5" + }, + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/protobufjs": { + "version": "7.5.4", + "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.5.4.tgz", + "integrity": "sha512-CvexbZtbov6jW2eXAvLukXjXUW1TzFaivC46BpWc/3BpcCysb5Vffu+B3XHMm8lVEuy2Mm4XGex8hBSg1yapPg==", + "hasInstallScript": true, + "license": "BSD-3-Clause", + "optional": true, + "dependencies": { + "@protobufjs/aspromise": "^1.1.2", + "@protobufjs/base64": "^1.1.2", + "@protobufjs/codegen": "^2.0.4", + "@protobufjs/eventemitter": "^1.1.0", + "@protobufjs/fetch": "^1.1.0", + "@protobufjs/float": "^1.0.2", + "@protobufjs/inquire": "^1.1.0", + "@protobufjs/path": "^1.1.2", + "@protobufjs/pool": "^1.1.0", + "@protobufjs/utf8": "^1.1.0", + "@types/node": ">=13.7.0", + "long": "^5.0.0" + }, + "engines": { + "node": ">=12.0.0" + } + }, + "node_modules/proxy-addr": { + "version": "2.0.7", + "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz", + "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==", + "license": "MIT", + "dependencies": { + "forwarded": "0.2.0", + "ipaddr.js": "1.9.1" + }, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/qs": { + "version": "6.14.2", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.14.2.tgz", + "integrity": "sha512-V/yCWTTF7VJ9hIh18Ugr2zhJMP01MY7c5kh4J870L7imm6/DIzBsNLTXzMwUA3yZ5b/KBqLx8Kp3uRvd7xSe3Q==", + "license": "BSD-3-Clause", + "dependencies": { + "side-channel": "^1.1.0" + }, + "engines": { + "node": ">=0.6" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/quick-format-unescaped": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/quick-format-unescaped/-/quick-format-unescaped-4.0.4.tgz", + "integrity": "sha512-tYC1Q1hgyRuHgloV/YXs2w15unPVh8qfu/qCTfhTYamaw7fyhumKa2yGpdSo87vY32rIclj+4fWYQXUMs9EHvg==", + "license": "MIT" + }, + "node_modules/range-parser": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz", + "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/raw-body": { + "version": "2.5.3", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.3.tgz", + "integrity": "sha512-s4VSOf6yN0rvbRZGxs8Om5CWj6seneMwK3oDb4lWDH0UPhWcxwOWw5+qk24bxq87szX1ydrwylIOp2uG1ojUpA==", + "license": "MIT", + "dependencies": { + "bytes": "~3.1.2", + "http-errors": "~2.0.1", + "iconv-lite": "~0.4.24", + "unpipe": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/readable-stream": { + "version": "3.6.2", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz", + "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==", + "license": "MIT", + "optional": true, + "dependencies": { + "inherits": "^2.0.3", + "string_decoder": "^1.1.1", + "util-deprecate": "^1.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/real-require": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/real-require/-/real-require-0.2.0.tgz", + "integrity": "sha512-57frrGM/OCTLqLOAh0mhVA9VBMHd+9U7Zb2THMGdBUoZVOtGbJzjxsYGDJ3A9AYYCP4hn6y1TVbaOfzWtm5GFg==", + "license": "MIT", + "engines": { + "node": ">= 12.13.0" + } + }, + "node_modules/require-directory": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", + "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==", + "license": "MIT", + "optional": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/retry": { + "version": "0.13.1", + "resolved": "https://registry.npmjs.org/retry/-/retry-0.13.1.tgz", + "integrity": "sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg==", + "license": "MIT", + "optional": true, + "engines": { + "node": ">= 4" + } + }, + "node_modules/retry-request": { + "version": "7.0.2", + "resolved": "https://registry.npmjs.org/retry-request/-/retry-request-7.0.2.tgz", + "integrity": "sha512-dUOvLMJ0/JJYEn8NrpOaGNE7X3vpI5XlZS/u0ANjqtcZVKnIxP7IgCFwrKTxENw29emmwug53awKtaMm4i9g5w==", + "license": "MIT", + "optional": true, + "dependencies": { + "@types/request": "^2.48.8", + "extend": "^3.0.2", + "teeny-request": "^9.0.0" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/safe-buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/safe-stable-stringify": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/safe-stable-stringify/-/safe-stable-stringify-2.5.0.tgz", + "integrity": "sha512-b3rppTKm9T+PsVCBEOUR46GWI7fdOs00VKZ1+9c1EWDaDMvjQc6tUwuFyIprgGgTcWoVHSKrU8H31ZHA2e0RHA==", + "license": "MIT", + "engines": { + "node": ">=10" + } + }, + "node_modules/safer-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", + "license": "MIT" + }, + "node_modules/semver": { + "version": "7.7.4", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz", + "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==", + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/send": { + "version": "0.19.2", + "resolved": "https://registry.npmjs.org/send/-/send-0.19.2.tgz", + "integrity": "sha512-VMbMxbDeehAxpOtWJXlcUS5E8iXh6QmN+BkRX1GARS3wRaXEEgzCcB10gTQazO42tpNIya8xIyNx8fll1OFPrg==", + "license": "MIT", + "dependencies": { + "debug": "2.6.9", + "depd": "2.0.0", + "destroy": "1.2.0", + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "fresh": "~0.5.2", + "http-errors": "~2.0.1", + "mime": "1.6.0", + "ms": "2.1.3", + "on-finished": "~2.4.1", + "range-parser": "~1.2.1", + "statuses": "~2.0.2" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/send/node_modules/mime": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz", + "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==", + "license": "MIT", + "bin": { + "mime": "cli.js" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/send/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "license": "MIT" + }, + "node_modules/serve-static": { + "version": "1.16.3", + "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.3.tgz", + "integrity": "sha512-x0RTqQel6g5SY7Lg6ZreMmsOzncHFU7nhnRWkKgWuMTu5NN0DR5oruckMqRvacAN9d5w6ARnRBXl9xhDCgfMeA==", + "license": "MIT", + "dependencies": { + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "parseurl": "~1.3.3", + "send": "~0.19.1" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/setprototypeof": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz", + "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==", + "license": "ISC" + }, + "node_modules/side-channel": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz", + "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "object-inspect": "^1.13.3", + "side-channel-list": "^1.0.0", + "side-channel-map": "^1.0.1", + "side-channel-weakmap": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-list": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz", + "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "object-inspect": "^1.13.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-map": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz", + "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-weakmap": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz", + "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3", + "side-channel-map": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/sonic-boom": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/sonic-boom/-/sonic-boom-4.2.1.tgz", + "integrity": "sha512-w6AxtubXa2wTXAUsZMMWERrsIRAdrK0Sc+FUytWvYAhBJLyuI4llrMIC1DtlNSdI99EI86KZum2MMq3EAZlF9Q==", + "license": "MIT", + "dependencies": { + "atomic-sleep": "^1.0.0" + } + }, + "node_modules/split2": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/split2/-/split2-4.2.0.tgz", + "integrity": "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==", + "license": "ISC", + "engines": { + "node": ">= 10.x" + } + }, + "node_modules/statuses": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.2.tgz", + "integrity": "sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/stream-events": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/stream-events/-/stream-events-1.0.5.tgz", + "integrity": "sha512-E1GUzBSgvct8Jsb3v2X15pjzN1tYebtbLaMg+eBOUOAxgbLoSbT2NS91ckc5lJD1KfLjId+jXJRgo0qnV5Nerg==", + "license": "MIT", + "optional": true, + "dependencies": { + "stubs": "^3.0.0" + } + }, + "node_modules/stream-shift": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/stream-shift/-/stream-shift-1.0.3.tgz", + "integrity": "sha512-76ORR0DO1o1hlKwTbi/DM3EXWGf3ZJYO8cXX5RJwnul2DEg2oyoZyjLNoQM8WsvZiFKCRfC1O0J7iCvie3RZmQ==", + "license": "MIT", + "optional": true + }, + "node_modules/string_decoder": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz", + "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==", + "license": "MIT", + "optional": true, + "dependencies": { + "safe-buffer": "~5.2.0" + } + }, + "node_modules/string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "license": "MIT", + "optional": true, + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "license": "MIT", + "optional": true, + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strnum": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/strnum/-/strnum-2.1.2.tgz", + "integrity": "sha512-l63NF9y/cLROq/yqKXSLtcMeeyOfnSQlfMSlzFt/K73oIaD8DGaQWd7Z34X9GPiKqP5rbSh84Hl4bOlLcjiSrQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/NaturalIntelligence" + } + ], + "license": "MIT", + "optional": true + }, + "node_modules/stubs": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/stubs/-/stubs-3.0.0.tgz", + "integrity": "sha512-PdHt7hHUJKxvTCgbKX9C1V/ftOcjJQgz8BZwNfV5c4B6dcGqlpelTbJ999jBGZ2jYiPAwcX5dP6oBwVlBlUbxw==", + "license": "MIT", + "optional": true + }, + "node_modules/superagent": { + "version": "10.3.0", + "resolved": "https://registry.npmjs.org/superagent/-/superagent-10.3.0.tgz", + "integrity": "sha512-B+4Ik7ROgVKrQsXTV0Jwp2u+PXYLSlqtDAhYnkkD+zn3yg8s/zjA2MeGayPoY/KICrbitwneDHrjSotxKL+0XQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "component-emitter": "^1.3.1", + "cookiejar": "^2.1.4", + "debug": "^4.3.7", + "fast-safe-stringify": "^2.1.1", + "form-data": "^4.0.5", + "formidable": "^3.5.4", + "methods": "^1.1.2", + "mime": "2.6.0", + "qs": "^6.14.1" + }, + "engines": { + "node": ">=14.18.0" + } + }, + "node_modules/superagent/node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/superagent/node_modules/form-data": { + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz", + "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==", + "dev": true, + "license": "MIT", + "dependencies": { + "asynckit": "^0.4.0", + "combined-stream": "^1.0.8", + "es-set-tostringtag": "^2.1.0", + "hasown": "^2.0.2", + "mime-types": "^2.1.12" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/superagent/node_modules/mime": { + "version": "2.6.0", + "resolved": "https://registry.npmjs.org/mime/-/mime-2.6.0.tgz", + "integrity": "sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg==", + "dev": true, + "license": "MIT", + "bin": { + "mime": "cli.js" + }, + "engines": { + "node": ">=4.0.0" + } + }, + "node_modules/superagent/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true, + "license": "MIT" + }, + "node_modules/supertest": { + "version": "7.2.2", + "resolved": "https://registry.npmjs.org/supertest/-/supertest-7.2.2.tgz", + "integrity": "sha512-oK8WG9diS3DlhdUkcFn4tkNIiIbBx9lI2ClF8K+b2/m8Eyv47LSawxUzZQSNKUrVb2KsqeTDCcjAAVPYaSLVTA==", + "dev": true, + "license": "MIT", + "dependencies": { + "cookie-signature": "^1.2.2", + "methods": "^1.1.2", + "superagent": "^10.3.0" + }, + "engines": { + "node": ">=14.18.0" + } + }, + "node_modules/supertest/node_modules/cookie-signature": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.2.2.tgz", + "integrity": "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.6.0" + } + }, + "node_modules/teeny-request": { + "version": "9.0.0", + "resolved": "https://registry.npmjs.org/teeny-request/-/teeny-request-9.0.0.tgz", + "integrity": "sha512-resvxdc6Mgb7YEThw6G6bExlXKkv6+YbuzGg9xuXxSgxJF7Ozs+o8Y9+2R3sArdWdW8nOokoQb1yrpFB0pQK2g==", + "license": "Apache-2.0", + "optional": true, + "dependencies": { + "http-proxy-agent": "^5.0.0", + "https-proxy-agent": "^5.0.0", + "node-fetch": "^2.6.9", + "stream-events": "^1.0.5", + "uuid": "^9.0.0" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/teeny-request/node_modules/agent-base": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz", + "integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==", + "license": "MIT", + "optional": true, + "dependencies": { + "debug": "4" + }, + "engines": { + "node": ">= 6.0.0" + } + }, + "node_modules/teeny-request/node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "license": "MIT", + "optional": true, + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/teeny-request/node_modules/https-proxy-agent": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz", + "integrity": "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==", + "license": "MIT", + "optional": true, + "dependencies": { + "agent-base": "6", + "debug": "4" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/teeny-request/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "license": "MIT", + "optional": true + }, + "node_modules/teeny-request/node_modules/uuid": { + "version": "9.0.1", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-9.0.1.tgz", + "integrity": "sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA==", + "funding": [ + "https://github.com/sponsors/broofa", + "https://github.com/sponsors/ctavan" + ], + "license": "MIT", + "optional": true, + "bin": { + "uuid": "dist/bin/uuid" + } + }, + "node_modules/thread-stream": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/thread-stream/-/thread-stream-3.1.0.tgz", + "integrity": "sha512-OqyPZ9u96VohAyMfJykzmivOrY2wfMSf3C5TtFJVgN+Hm6aj+voFhlK+kZEIv2FBh1X6Xp3DlnCOfEQ3B2J86A==", + "license": "MIT", + "dependencies": { + "real-require": "^0.2.0" + } + }, + "node_modules/toidentifier": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz", + "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==", + "license": "MIT", + "engines": { + "node": ">=0.6" + } + }, + "node_modules/tr46": { + "version": "0.0.3", + "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz", + "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==", + "license": "MIT" + }, + "node_modules/tslib": { + "version": "2.8.1", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz", + "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==", + "license": "0BSD" + }, + "node_modules/type-is": { + "version": "1.6.18", + "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz", + "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==", + "license": "MIT", + "dependencies": { + "media-typer": "0.3.0", + "mime-types": "~2.1.24" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/undici-types": { + "version": "6.21.0", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz", + "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==", + "license": "MIT" + }, + "node_modules/unpipe": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz", + "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==", + "license": "MIT", + "optional": true + }, + "node_modules/utils-merge": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz", + "integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==", + "license": "MIT", + "engines": { + "node": ">= 0.4.0" + } + }, + "node_modules/uuid": { + "version": "11.1.0", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-11.1.0.tgz", + "integrity": "sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A==", + "funding": [ + "https://github.com/sponsors/broofa", + "https://github.com/sponsors/ctavan" + ], + "license": "MIT", + "bin": { + "uuid": "dist/esm/bin/uuid" + } + }, + "node_modules/vary": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz", + "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/webidl-conversions": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz", + "integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==", + "license": "BSD-2-Clause" + }, + "node_modules/websocket-driver": { + "version": "0.7.4", + "resolved": "https://registry.npmjs.org/websocket-driver/-/websocket-driver-0.7.4.tgz", + "integrity": "sha512-b17KeDIQVjvb0ssuSDF2cYXSg2iztliJ4B9WdsuB6J952qCPKmnVq4DyW5motImXHDC1cBT/1UezrJVsKw5zjg==", + "license": "Apache-2.0", + "dependencies": { + "http-parser-js": ">=0.5.1", + "safe-buffer": ">=5.1.0", + "websocket-extensions": ">=0.1.1" + }, + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/websocket-extensions": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/websocket-extensions/-/websocket-extensions-0.1.4.tgz", + "integrity": "sha512-OqedPIGOfsDlo31UNwYbCFMSaO9m9G/0faIHj5/dZFDMFqPTcx6UwqyOy3COEaEOg/9VsGIpdqn62W5KhoKSpg==", + "license": "Apache-2.0", + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/whatwg-url": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz", + "integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==", + "license": "MIT", + "dependencies": { + "tr46": "~0.0.3", + "webidl-conversions": "^3.0.0" + } + }, + "node_modules/wrap-ansi": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "license": "MIT", + "optional": true, + "dependencies": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==", + "devOptional": true, + "license": "ISC" + }, + "node_modules/y18n": { + "version": "5.0.8", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", + "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==", + "license": "ISC", + "optional": true, + "engines": { + "node": ">=10" + } + }, + "node_modules/yallist": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", + "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", + "license": "ISC" + }, + "node_modules/yargs": { + "version": "17.7.2", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz", + "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==", + "license": "MIT", + "optional": true, + "dependencies": { + "cliui": "^8.0.1", + "escalade": "^3.1.1", + "get-caller-file": "^2.0.5", + "require-directory": "^2.1.1", + "string-width": "^4.2.3", + "y18n": "^5.0.5", + "yargs-parser": "^21.1.1" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/yargs-parser": { + "version": "21.1.1", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz", + "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==", + "license": "ISC", + "optional": true, + "engines": { + "node": ">=12" + } + }, + "node_modules/yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "license": "MIT", + "optional": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + } + } +} diff --git a/backend/query-api/package.json b/backend/query-api/package.json new file mode 100644 index 00000000..4c30b282 --- /dev/null +++ b/backend/query-api/package.json @@ -0,0 +1,22 @@ +{ + "name": "@krow/query-api", + "version": "0.1.0", + "private": true, + "type": "module", + "engines": { + "node": ">=20" + }, + "scripts": { + "start": "node src/server.js", + "test": "node --test" + }, + "dependencies": { + "express": "^4.21.2", + "firebase-admin": "^13.0.2", + "pino": "^9.6.0", + "pino-http": "^10.3.0" + }, + "devDependencies": { + "supertest": "^7.0.0" + } +} diff --git a/backend/query-api/src/app.js b/backend/query-api/src/app.js new file mode 100644 index 00000000..41573544 --- /dev/null +++ b/backend/query-api/src/app.js @@ -0,0 +1,28 @@ +import express from 'express'; +import pino from 'pino'; +import pinoHttp from 'pino-http'; +import { requestContext } from './middleware/request-context.js'; +import { errorHandler, notFoundHandler } from './middleware/error-handler.js'; +import { healthRouter } from './routes/health.js'; + +const logger = pino({ level: process.env.LOG_LEVEL || 'info' }); + +export function createApp() { + const app = express(); + + app.use(requestContext); + app.use( + pinoHttp({ + logger, + customProps: (req) => ({ requestId: req.requestId }), + }) + ); + app.use(express.json({ limit: '2mb' })); + + app.use(healthRouter); + + app.use(notFoundHandler); + app.use(errorHandler); + + return app; +} diff --git a/backend/query-api/src/lib/errors.js b/backend/query-api/src/lib/errors.js new file mode 100644 index 00000000..05548b32 --- /dev/null +++ b/backend/query-api/src/lib/errors.js @@ -0,0 +1,26 @@ +export class AppError extends Error { + constructor(code, message, status = 400, details = {}) { + super(message); + this.name = 'AppError'; + this.code = code; + this.status = status; + this.details = details; + } +} + +export function toErrorEnvelope(error, requestId) { + const status = error?.status && Number.isInteger(error.status) ? error.status : 500; + const code = error?.code || 'INTERNAL_ERROR'; + const message = error?.message || 'Unexpected error'; + const details = error?.details || {}; + + return { + status, + body: { + code, + message, + details, + requestId, + }, + }; +} diff --git a/backend/query-api/src/middleware/error-handler.js b/backend/query-api/src/middleware/error-handler.js new file mode 100644 index 00000000..289395f3 --- /dev/null +++ b/backend/query-api/src/middleware/error-handler.js @@ -0,0 +1,25 @@ +import { toErrorEnvelope } from '../lib/errors.js'; + +export function notFoundHandler(req, res) { + res.status(404).json({ + code: 'NOT_FOUND', + message: `Route not found: ${req.method} ${req.path}`, + details: {}, + requestId: req.requestId, + }); +} + +export function errorHandler(error, req, res, _next) { + const envelope = toErrorEnvelope(error, req.requestId); + if (req.log) { + req.log.error( + { + errCode: envelope.body.code, + status: envelope.status, + details: envelope.body.details, + }, + envelope.body.message + ); + } + res.status(envelope.status).json(envelope.body); +} diff --git a/backend/query-api/src/middleware/request-context.js b/backend/query-api/src/middleware/request-context.js new file mode 100644 index 00000000..c633acbb --- /dev/null +++ b/backend/query-api/src/middleware/request-context.js @@ -0,0 +1,9 @@ +import { randomUUID } from 'node:crypto'; + +export function requestContext(req, res, next) { + const incoming = req.get('X-Request-Id'); + req.requestId = incoming || randomUUID(); + res.setHeader('X-Request-Id', req.requestId); + res.locals.startedAt = Date.now(); + next(); +} diff --git a/backend/query-api/src/routes/health.js b/backend/query-api/src/routes/health.js new file mode 100644 index 00000000..142dbf78 --- /dev/null +++ b/backend/query-api/src/routes/health.js @@ -0,0 +1,15 @@ +import { Router } from 'express'; + +export const healthRouter = Router(); + +function healthHandler(req, res) { + res.status(200).json({ + ok: true, + service: 'krow-query-api', + version: process.env.SERVICE_VERSION || 'dev', + requestId: req.requestId, + }); +} + +healthRouter.get('/health', healthHandler); +healthRouter.get('/healthz', healthHandler); diff --git a/backend/query-api/src/server.js b/backend/query-api/src/server.js new file mode 100644 index 00000000..02002d9a --- /dev/null +++ b/backend/query-api/src/server.js @@ -0,0 +1,9 @@ +import { createApp } from './app.js'; + +const port = Number(process.env.PORT || 8080); +const app = createApp(); + +app.listen(port, () => { + // eslint-disable-next-line no-console + console.log(`krow-query-api listening on port ${port}`); +}); diff --git a/backend/query-api/test/app.test.js b/backend/query-api/test/app.test.js new file mode 100644 index 00000000..d2274ba5 --- /dev/null +++ b/backend/query-api/test/app.test.js @@ -0,0 +1,24 @@ +import test from 'node:test'; +import assert from 'node:assert/strict'; +import request from 'supertest'; +import { createApp } from '../src/app.js'; + +test('GET /healthz returns healthy response', async () => { + const app = createApp(); + const res = await request(app).get('/healthz'); + + assert.equal(res.status, 200); + assert.equal(res.body.ok, true); + assert.equal(res.body.service, 'krow-query-api'); + assert.equal(typeof res.body.requestId, 'string'); + assert.equal(typeof res.headers['x-request-id'], 'string'); +}); + +test('GET unknown route returns not found envelope', async () => { + const app = createApp(); + const res = await request(app).get('/query/unknown'); + + assert.equal(res.status, 404); + assert.equal(res.body.code, 'NOT_FOUND'); + assert.equal(typeof res.body.requestId, 'string'); +}); diff --git a/makefiles/backend.mk b/makefiles/backend.mk index 5ee113c0..de0ab649 100644 --- a/makefiles/backend.mk +++ b/makefiles/backend.mk @@ -36,7 +36,41 @@ BACKEND_VERIFICATION_PROVIDER_TIMEOUT_MS ?= 8000 BACKEND_MAX_SIGNED_URL_SECONDS ?= 900 BACKEND_LLM_RATE_LIMIT_PER_MINUTE ?= 20 -.PHONY: backend-help backend-enable-apis backend-bootstrap-dev backend-migrate-idempotency backend-deploy-core backend-deploy-commands backend-deploy-workers backend-smoke-core backend-smoke-commands backend-logs-core +BACKEND_V2_ARTIFACT_REPO ?= krow-backend-v2 +BACKEND_V2_CORE_SERVICE_NAME ?= krow-core-api-v2 +BACKEND_V2_COMMAND_SERVICE_NAME ?= krow-command-api-v2 +BACKEND_V2_QUERY_SERVICE_NAME ?= krow-query-api-v2 +BACKEND_V2_RUNTIME_SA_NAME ?= krow-backend-v2-runtime +BACKEND_V2_RUNTIME_SA_EMAIL := $(BACKEND_V2_RUNTIME_SA_NAME)@$(GCP_PROJECT_ID).iam.gserviceaccount.com + +BACKEND_V2_CORE_DIR ?= backend/core-api +BACKEND_V2_COMMAND_DIR ?= backend/command-api +BACKEND_V2_QUERY_DIR ?= backend/query-api + +BACKEND_V2_SQL_INSTANCE ?= krow-sql-v2 +BACKEND_V2_SQL_DATABASE ?= krow_v2_db +BACKEND_V2_SQL_TIER ?= $(SQL_TIER) + +BACKEND_V2_DEV_PUBLIC_BUCKET ?= krow-workforce-dev-v2-public +BACKEND_V2_DEV_PRIVATE_BUCKET ?= krow-workforce-dev-v2-private +BACKEND_V2_STAGING_PUBLIC_BUCKET ?= krow-workforce-staging-v2-public +BACKEND_V2_STAGING_PRIVATE_BUCKET ?= krow-workforce-staging-v2-private + +ifeq ($(ENV),staging) + BACKEND_V2_PUBLIC_BUCKET := $(BACKEND_V2_STAGING_PUBLIC_BUCKET) + BACKEND_V2_PRIVATE_BUCKET := $(BACKEND_V2_STAGING_PRIVATE_BUCKET) + BACKEND_V2_RUN_AUTH_FLAG := --no-allow-unauthenticated +else + BACKEND_V2_PUBLIC_BUCKET := $(BACKEND_V2_DEV_PUBLIC_BUCKET) + BACKEND_V2_PRIVATE_BUCKET := $(BACKEND_V2_DEV_PRIVATE_BUCKET) + BACKEND_V2_RUN_AUTH_FLAG := --allow-unauthenticated +endif + +BACKEND_V2_CORE_IMAGE ?= $(BACKEND_REGION)-docker.pkg.dev/$(GCP_PROJECT_ID)/$(BACKEND_V2_ARTIFACT_REPO)/core-api-v2:latest +BACKEND_V2_COMMAND_IMAGE ?= $(BACKEND_REGION)-docker.pkg.dev/$(GCP_PROJECT_ID)/$(BACKEND_V2_ARTIFACT_REPO)/command-api-v2:latest +BACKEND_V2_QUERY_IMAGE ?= $(BACKEND_REGION)-docker.pkg.dev/$(GCP_PROJECT_ID)/$(BACKEND_V2_ARTIFACT_REPO)/query-api-v2:latest + +.PHONY: backend-help backend-enable-apis backend-bootstrap-dev backend-migrate-idempotency backend-deploy-core backend-deploy-commands backend-deploy-workers backend-smoke-core backend-smoke-commands backend-logs-core backend-bootstrap-v2-dev backend-deploy-core-v2 backend-deploy-commands-v2 backend-deploy-query-v2 backend-smoke-core-v2 backend-smoke-commands-v2 backend-smoke-query-v2 backend-logs-core-v2 backend-v2-migrate-idempotency backend-help: @echo "--> Backend Foundation Commands" @@ -49,6 +83,17 @@ backend-help: @echo " make backend-smoke-core [ENV=dev] Smoke test core /health" @echo " make backend-smoke-commands [ENV=dev] Smoke test commands /health" @echo " make backend-logs-core [ENV=dev] Read core service logs" + @echo "" + @echo "--> Backend Foundation Commands (isolated v2 stack)" + @echo " make backend-bootstrap-v2-dev [ENV=dev] Bootstrap isolated v2 resources and SQL instance" + @echo " make backend-deploy-core-v2 [ENV=dev] Build + deploy core API v2 service" + @echo " make backend-deploy-commands-v2 [ENV=dev] Build + deploy command API v2 service" + @echo " make backend-deploy-query-v2 [ENV=dev] Build + deploy query API v2 scaffold service" + @echo " make backend-v2-migrate-idempotency Apply command idempotency migration against v2 DB" + @echo " make backend-smoke-core-v2 [ENV=dev] Smoke test core API v2 /health" + @echo " make backend-smoke-commands-v2 [ENV=dev] Smoke test command API v2 /health" + @echo " make backend-smoke-query-v2 [ENV=dev] Smoke test query API v2 /health" + @echo " make backend-logs-core-v2 [ENV=dev] Read core API v2 logs" backend-enable-apis: @echo "--> Enabling backend APIs on project [$(GCP_PROJECT_ID)]..." @@ -190,3 +235,167 @@ backend-logs-core: --region=$(BACKEND_REGION) \ --project=$(GCP_PROJECT_ID) \ --limit=$(BACKEND_LOG_LIMIT) + +backend-bootstrap-v2-dev: backend-enable-apis + @echo "--> Bootstrapping isolated backend v2 foundation for [$(ENV)] on project [$(GCP_PROJECT_ID)]..." + @echo "--> Ensuring Artifact Registry repo [$(BACKEND_V2_ARTIFACT_REPO)] exists..." + @if ! gcloud artifacts repositories describe $(BACKEND_V2_ARTIFACT_REPO) --location=$(BACKEND_REGION) --project=$(GCP_PROJECT_ID) >/dev/null 2>&1; then \ + gcloud artifacts repositories create $(BACKEND_V2_ARTIFACT_REPO) \ + --repository-format=docker \ + --location=$(BACKEND_REGION) \ + --description="KROW backend v2 services" \ + --project=$(GCP_PROJECT_ID); \ + else \ + echo " - Artifact Registry repo already exists."; \ + fi + @echo "--> Ensuring v2 runtime service account [$(BACKEND_V2_RUNTIME_SA_NAME)] exists..." + @if ! gcloud iam service-accounts describe $(BACKEND_V2_RUNTIME_SA_EMAIL) --project=$(GCP_PROJECT_ID) >/dev/null 2>&1; then \ + gcloud iam service-accounts create $(BACKEND_V2_RUNTIME_SA_NAME) \ + --display-name="KROW Backend Runtime V2" \ + --project=$(GCP_PROJECT_ID); \ + else \ + echo " - Runtime service account already exists."; \ + fi + @echo "--> Ensuring v2 runtime service account IAM roles..." + @gcloud projects add-iam-policy-binding $(GCP_PROJECT_ID) \ + --member="serviceAccount:$(BACKEND_V2_RUNTIME_SA_EMAIL)" \ + --role="roles/storage.objectAdmin" \ + --quiet >/dev/null + @gcloud projects add-iam-policy-binding $(GCP_PROJECT_ID) \ + --member="serviceAccount:$(BACKEND_V2_RUNTIME_SA_EMAIL)" \ + --role="roles/aiplatform.user" \ + --quiet >/dev/null + @gcloud projects add-iam-policy-binding $(GCP_PROJECT_ID) \ + --member="serviceAccount:$(BACKEND_V2_RUNTIME_SA_EMAIL)" \ + --role="roles/cloudsql.client" \ + --quiet >/dev/null + @gcloud projects add-iam-policy-binding $(GCP_PROJECT_ID) \ + --member="serviceAccount:$(BACKEND_V2_RUNTIME_SA_EMAIL)" \ + --role="roles/secretmanager.secretAccessor" \ + --quiet >/dev/null + @gcloud iam service-accounts add-iam-policy-binding $(BACKEND_V2_RUNTIME_SA_EMAIL) \ + --member="serviceAccount:$(BACKEND_V2_RUNTIME_SA_EMAIL)" \ + --role="roles/iam.serviceAccountTokenCreator" \ + --project=$(GCP_PROJECT_ID) \ + --quiet >/dev/null + @echo "--> Ensuring v2 storage buckets exist..." + @if ! gcloud storage buckets describe gs://$(BACKEND_V2_PUBLIC_BUCKET) --project=$(GCP_PROJECT_ID) >/dev/null 2>&1; then \ + gcloud storage buckets create gs://$(BACKEND_V2_PUBLIC_BUCKET) --location=$(BACKEND_REGION) --project=$(GCP_PROJECT_ID); \ + else \ + echo " - Public bucket already exists: $(BACKEND_V2_PUBLIC_BUCKET)"; \ + fi + @if ! gcloud storage buckets describe gs://$(BACKEND_V2_PRIVATE_BUCKET) --project=$(GCP_PROJECT_ID) >/dev/null 2>&1; then \ + gcloud storage buckets create gs://$(BACKEND_V2_PRIVATE_BUCKET) --location=$(BACKEND_REGION) --project=$(GCP_PROJECT_ID); \ + else \ + echo " - Private bucket already exists: $(BACKEND_V2_PRIVATE_BUCKET)"; \ + fi + @echo "--> Ensuring v2 Cloud SQL instance [$(BACKEND_V2_SQL_INSTANCE)] exists..." + @if ! gcloud sql instances describe $(BACKEND_V2_SQL_INSTANCE) --project=$(GCP_PROJECT_ID) >/dev/null 2>&1; then \ + gcloud sql instances create $(BACKEND_V2_SQL_INSTANCE) \ + --database-version=POSTGRES_15 \ + --tier=$(BACKEND_V2_SQL_TIER) \ + --region=$(BACKEND_REGION) \ + --storage-size=10 \ + --storage-auto-increase \ + --availability-type=zonal \ + --backup-start-time=03:00 \ + --project=$(GCP_PROJECT_ID); \ + else \ + echo " - Cloud SQL instance already exists: $(BACKEND_V2_SQL_INSTANCE)"; \ + fi + @echo "--> Ensuring v2 Cloud SQL database [$(BACKEND_V2_SQL_DATABASE)] exists..." + @if ! gcloud sql databases describe $(BACKEND_V2_SQL_DATABASE) --instance=$(BACKEND_V2_SQL_INSTANCE) --project=$(GCP_PROJECT_ID) >/dev/null 2>&1; then \ + gcloud sql databases create $(BACKEND_V2_SQL_DATABASE) --instance=$(BACKEND_V2_SQL_INSTANCE) --project=$(GCP_PROJECT_ID); \ + else \ + echo " - Cloud SQL database already exists: $(BACKEND_V2_SQL_DATABASE)"; \ + fi + @echo "✅ Backend v2 foundation bootstrap complete for [$(ENV)]." + +backend-deploy-core-v2: + @echo "--> Deploying core backend v2 service [$(BACKEND_V2_CORE_SERVICE_NAME)] to [$(ENV)]..." + @test -d $(BACKEND_V2_CORE_DIR) || (echo "❌ Missing directory: $(BACKEND_V2_CORE_DIR)" && exit 1) + @test -f $(BACKEND_V2_CORE_DIR)/Dockerfile || (echo "❌ Missing Dockerfile: $(BACKEND_V2_CORE_DIR)/Dockerfile" && exit 1) + @gcloud builds submit $(BACKEND_V2_CORE_DIR) --tag $(BACKEND_V2_CORE_IMAGE) --project=$(GCP_PROJECT_ID) + @gcloud run deploy $(BACKEND_V2_CORE_SERVICE_NAME) \ + --image=$(BACKEND_V2_CORE_IMAGE) \ + --region=$(BACKEND_REGION) \ + --project=$(GCP_PROJECT_ID) \ + --service-account=$(BACKEND_V2_RUNTIME_SA_EMAIL) \ + --set-env-vars=APP_ENV=$(ENV),APP_STACK=v2,GCP_PROJECT_ID=$(GCP_PROJECT_ID),PUBLIC_BUCKET=$(BACKEND_V2_PUBLIC_BUCKET),PRIVATE_BUCKET=$(BACKEND_V2_PRIVATE_BUCKET),UPLOAD_MOCK=false,SIGNED_URL_MOCK=false,LLM_MOCK=false,LLM_LOCATION=$(BACKEND_REGION),LLM_MODEL=$(BACKEND_LLM_MODEL),LLM_TIMEOUT_MS=20000,MAX_SIGNED_URL_SECONDS=$(BACKEND_MAX_SIGNED_URL_SECONDS),LLM_RATE_LIMIT_PER_MINUTE=$(BACKEND_LLM_RATE_LIMIT_PER_MINUTE),VERIFICATION_ACCESS_MODE=authenticated,VERIFICATION_REQUIRE_FILE_EXISTS=true,VERIFICATION_ATTIRE_PROVIDER=vertex,VERIFICATION_ATTIRE_MODEL=$(BACKEND_VERIFICATION_ATTIRE_MODEL),VERIFICATION_PROVIDER_TIMEOUT_MS=$(BACKEND_VERIFICATION_PROVIDER_TIMEOUT_MS) \ + $(BACKEND_V2_RUN_AUTH_FLAG) + @echo "✅ Core backend v2 service deployed." + +backend-deploy-commands-v2: + @echo "--> Deploying command backend v2 service [$(BACKEND_V2_COMMAND_SERVICE_NAME)] to [$(ENV)]..." + @test -d $(BACKEND_V2_COMMAND_DIR) || (echo "❌ Missing directory: $(BACKEND_V2_COMMAND_DIR)" && exit 1) + @test -f $(BACKEND_V2_COMMAND_DIR)/Dockerfile || (echo "❌ Missing Dockerfile: $(BACKEND_V2_COMMAND_DIR)/Dockerfile" && exit 1) + @gcloud builds submit $(BACKEND_V2_COMMAND_DIR) --tag $(BACKEND_V2_COMMAND_IMAGE) --project=$(GCP_PROJECT_ID) + @EXTRA_ENV="APP_ENV=$(ENV),APP_STACK=v2,GCP_PROJECT_ID=$(GCP_PROJECT_ID),PUBLIC_BUCKET=$(BACKEND_V2_PUBLIC_BUCKET),PRIVATE_BUCKET=$(BACKEND_V2_PRIVATE_BUCKET),IDEMPOTENCY_STORE=memory"; \ + if [ -n "$(IDEMPOTENCY_DATABASE_URL)" ]; then \ + EXTRA_ENV="APP_ENV=$(ENV),APP_STACK=v2,GCP_PROJECT_ID=$(GCP_PROJECT_ID),PUBLIC_BUCKET=$(BACKEND_V2_PUBLIC_BUCKET),PRIVATE_BUCKET=$(BACKEND_V2_PRIVATE_BUCKET),IDEMPOTENCY_STORE=sql,IDEMPOTENCY_DATABASE_URL=$(IDEMPOTENCY_DATABASE_URL)"; \ + fi; \ + gcloud run deploy $(BACKEND_V2_COMMAND_SERVICE_NAME) \ + --image=$(BACKEND_V2_COMMAND_IMAGE) \ + --region=$(BACKEND_REGION) \ + --project=$(GCP_PROJECT_ID) \ + --service-account=$(BACKEND_V2_RUNTIME_SA_EMAIL) \ + --set-env-vars=$$EXTRA_ENV \ + $(BACKEND_V2_RUN_AUTH_FLAG) + @echo "✅ Command backend v2 service deployed." + +backend-deploy-query-v2: + @echo "--> Deploying query backend v2 service [$(BACKEND_V2_QUERY_SERVICE_NAME)] to [$(ENV)]..." + @test -d $(BACKEND_V2_QUERY_DIR) || (echo "❌ Missing directory: $(BACKEND_V2_QUERY_DIR)" && exit 1) + @test -f $(BACKEND_V2_QUERY_DIR)/Dockerfile || (echo "❌ Missing Dockerfile: $(BACKEND_V2_QUERY_DIR)/Dockerfile" && exit 1) + @gcloud builds submit $(BACKEND_V2_QUERY_DIR) --tag $(BACKEND_V2_QUERY_IMAGE) --project=$(GCP_PROJECT_ID) + @gcloud run deploy $(BACKEND_V2_QUERY_SERVICE_NAME) \ + --image=$(BACKEND_V2_QUERY_IMAGE) \ + --region=$(BACKEND_REGION) \ + --project=$(GCP_PROJECT_ID) \ + --service-account=$(BACKEND_V2_RUNTIME_SA_EMAIL) \ + --set-env-vars=APP_ENV=$(ENV),APP_STACK=v2,GCP_PROJECT_ID=$(GCP_PROJECT_ID) \ + $(BACKEND_V2_RUN_AUTH_FLAG) + @echo "✅ Query backend v2 service deployed." + +backend-v2-migrate-idempotency: + @echo "--> Applying idempotency table migration for command API v2..." + @test -n "$(IDEMPOTENCY_DATABASE_URL)" || (echo "❌ IDEMPOTENCY_DATABASE_URL is required" && exit 1) + @cd $(BACKEND_V2_COMMAND_DIR) && IDEMPOTENCY_DATABASE_URL="$(IDEMPOTENCY_DATABASE_URL)" npm run migrate:idempotency + @echo "✅ Idempotency migration applied for command API v2." + +backend-smoke-core-v2: + @echo "--> Running core v2 smoke check..." + @URL=$$(gcloud run services describe $(BACKEND_V2_CORE_SERVICE_NAME) --region=$(BACKEND_REGION) --project=$(GCP_PROJECT_ID) --format='value(status.url)'); \ + if [ -z "$$URL" ]; then \ + echo "❌ Could not resolve URL for service $(BACKEND_V2_CORE_SERVICE_NAME)"; \ + exit 1; \ + fi; \ + TOKEN=$$(gcloud auth print-identity-token); \ + curl -fsS -H "Authorization: Bearer $$TOKEN" "$$URL/health" >/dev/null && echo "✅ Core v2 smoke check passed: $$URL/health" + +backend-smoke-commands-v2: + @echo "--> Running command v2 smoke check..." + @URL=$$(gcloud run services describe $(BACKEND_V2_COMMAND_SERVICE_NAME) --region=$(BACKEND_REGION) --project=$(GCP_PROJECT_ID) --format='value(status.url)'); \ + if [ -z "$$URL" ]; then \ + echo "❌ Could not resolve URL for service $(BACKEND_V2_COMMAND_SERVICE_NAME)"; \ + exit 1; \ + fi; \ + TOKEN=$$(gcloud auth print-identity-token); \ + curl -fsS -H "Authorization: Bearer $$TOKEN" "$$URL/health" >/dev/null && echo "✅ Command v2 smoke check passed: $$URL/health" + +backend-smoke-query-v2: + @echo "--> Running query v2 smoke check..." + @URL=$$(gcloud run services describe $(BACKEND_V2_QUERY_SERVICE_NAME) --region=$(BACKEND_REGION) --project=$(GCP_PROJECT_ID) --format='value(status.url)'); \ + if [ -z "$$URL" ]; then \ + echo "❌ Could not resolve URL for service $(BACKEND_V2_QUERY_SERVICE_NAME)"; \ + exit 1; \ + fi; \ + TOKEN=$$(gcloud auth print-identity-token); \ + curl -fsS -H "Authorization: Bearer $$TOKEN" "$$URL/health" >/dev/null && echo "✅ Query v2 smoke check passed: $$URL/health" + +backend-logs-core-v2: + @echo "--> Reading logs for core backend v2 service [$(BACKEND_V2_CORE_SERVICE_NAME)]..." + @gcloud run services logs read $(BACKEND_V2_CORE_SERVICE_NAME) \ + --region=$(BACKEND_REGION) \ + --project=$(GCP_PROJECT_ID) \ + --limit=$(BACKEND_LOG_LIMIT) From e483ea590005e721e3333a98f94140b70efbf819 Mon Sep 17 00:00:00 2001 From: zouantchaw <44246692+zouantchaw@users.noreply.github.com> Date: Wed, 11 Mar 2026 16:50:47 +0100 Subject: [PATCH 03/21] chore: remove trailing whitespace from gcp cloud run skill --- .agents/skills/gcp-cloud-run/SKILL.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.agents/skills/gcp-cloud-run/SKILL.md b/.agents/skills/gcp-cloud-run/SKILL.md index bd344b3c..c15feb80 100644 --- a/.agents/skills/gcp-cloud-run/SKILL.md +++ b/.agents/skills/gcp-cloud-run/SKILL.md @@ -105,7 +105,7 @@ steps: - '--cpu=1' - '--min-instances=1' - '--max-instances=100' - + ``` ### Cloud Run Functions Pattern From 50cb493c5312cdbfbfc7e9eb2e9b3599ab13b92e Mon Sep 17 00:00:00 2001 From: zouantchaw <44246692+zouantchaw@users.noreply.github.com> Date: Wed, 11 Mar 2026 16:58:26 +0100 Subject: [PATCH 04/21] Update validation Data Connect seed data --- backend/dataconnect/functions/clean.gql | 7 +- backend/dataconnect/functions/seed.gql | 825 +++++++++++++++++++++++- 2 files changed, 829 insertions(+), 3 deletions(-) diff --git a/backend/dataconnect/functions/clean.gql b/backend/dataconnect/functions/clean.gql index df8e84d5..c5ba6739 100644 --- a/backend/dataconnect/functions/clean.gql +++ b/backend/dataconnect/functions/clean.gql @@ -16,15 +16,18 @@ mutation unseedAll @auth(level: USER) { invoiceTemplate_deleteMany(all: true) customRateCard_deleteMany(all: true) vendorRate_deleteMany(all: true) - vendorBenefitPlan_deleteMany(all: true) + benefitsData_deleteMany(all: true) + workforce_deleteMany(all: true) staffCourse_deleteMany(all: true) staffDocument_deleteMany(all: true) + staffAttire_deleteMany(all: true) staffRole_deleteMany(all: true) staffAvailability_deleteMany(all: true) staffAvailabilityStats_deleteMany(all: true) emergencyContact_deleteMany(all: true) taxForm_deleteMany(all: true) certificate_deleteMany(all: true) + vendorBenefitPlan_deleteMany(all: true) # ---------------------------------- # Tasks / Shifts / Orders @@ -33,6 +36,7 @@ mutation unseedAll @auth(level: USER) { shiftRole_deleteMany(all: true) shift_deleteMany(all: true) order_deleteMany(all: true) + costCenter_deleteMany(all: true) # ---------------------------------- # Teams / Hubs / Org @@ -52,7 +56,6 @@ mutation unseedAll @auth(level: USER) { level_deleteMany(all: true) course_deleteMany(all: true) faqData_deleteMany(all: true) - benefitsData_deleteMany(all: true) attireOption_deleteMany(all: true) document_deleteMany(all: true) diff --git a/backend/dataconnect/functions/seed.gql b/backend/dataconnect/functions/seed.gql index 3a5f65ea..a87c3366 100644 --- a/backend/dataconnect/functions/seed.gql +++ b/backend/dataconnect/functions/seed.gql @@ -493,6 +493,208 @@ mutation seedAll @transaction { } ) + # Workforce assignments + workforce_1: workforce_insert( + data: { + id: "7f1d6cf2-4a26-4a3e-9d1b-1d68ca2a1001" + vendorId: "c3b25c47-0ebd-4402-a9b1-b8a875a7f71a" + staffId: "633df3ce-b92c-473f-90d8-38dd027fdf57" + workforceNumber: "WF-1001" + employmentType: W2 + status: ACTIVE + createdBy: "seed-script" + } + ) + workforce_2: workforce_insert( + data: { + id: "7f1d6cf2-4a26-4a3e-9d1b-1d68ca2a1002" + vendorId: "c3b25c47-0ebd-4402-a9b1-b8a875a7f71a" + staffId: "9631581a-1601-4e06-8e5e-600e9f305bcf" + workforceNumber: "WF-1002" + employmentType: W1099 + status: ACTIVE + createdBy: "seed-script" + } + ) + workforce_3: workforce_insert( + data: { + id: "7f1d6cf2-4a26-4a3e-9d1b-1d68ca2a1003" + vendorId: "c3b25c47-0ebd-4402-a9b1-b8a875a7f71a" + staffId: "2b678a6d-b8cd-4d5e-95ae-f35e4569f92c" + workforceNumber: "WF-1003" + employmentType: W2 + status: ACTIVE + createdBy: "seed-script" + } + ) + workforce_4: workforce_insert( + data: { + id: "7f1d6cf2-4a26-4a3e-9d1b-1d68ca2a1004" + vendorId: "c3b25c47-0ebd-4402-a9b1-b8a875a7f71a" + staffId: "d62605f9-366d-42c5-8f3b-f276c0d27ea3" + workforceNumber: "WF-1004" + employmentType: W2 + status: ACTIVE + createdBy: "seed-script" + } + ) + workforce_5: workforce_insert( + data: { + id: "7f1d6cf2-4a26-4a3e-9d1b-1d68ca2a1005" + vendorId: "c3b25c47-0ebd-4402-a9b1-b8a875a7f71a" + staffId: "c6428f90-9c29-4e5c-b362-dc67a9a8cbba" + workforceNumber: "WF-1005" + employmentType: W1099 + status: ACTIVE + createdBy: "seed-script" + } + ) + workforce_6: workforce_insert( + data: { + id: "7f1d6cf2-4a26-4a3e-9d1b-1d68ca2a1006" + vendorId: "c3b25c47-0ebd-4402-a9b1-b8a875a7f71a" + staffId: "56d7178c-f4ab-4c50-9b1f-d6efe25ba50b" + workforceNumber: "WF-1006" + employmentType: CONTRACT + status: ACTIVE + createdBy: "seed-script" + } + ) + workforce_7: workforce_insert( + data: { + id: "7f1d6cf2-4a26-4a3e-9d1b-1d68ca2a1007" + vendorId: "c3b25c47-0ebd-4402-a9b1-b8a875a7f71a" + staffId: "e7f8a9b0-c1d2-4e5f-a6b7-c8d9e0f1a2b3" + workforceNumber: "WF-1007" + employmentType: W2 + status: ACTIVE + createdBy: "seed-script" + } + ) + + # Benefit plans + benefit_plan_1: vendorBenefitPlan_insert( + data: { + id: "2d8f7d4b-1f90-4d8b-8b9d-9200d8f01001" + vendorId: "c3b25c47-0ebd-4402-a9b1-b8a875a7f71a" + title: "Paid Time Off" + description: "Annual paid time off allowance." + requestLabel: "Request PTO" + total: 80 + isActive: true + } + ) + benefit_plan_2: vendorBenefitPlan_insert( + data: { + id: "2d8f7d4b-1f90-4d8b-8b9d-9200d8f01002" + vendorId: "c3b25c47-0ebd-4402-a9b1-b8a875a7f71a" + title: "Sick Leave" + description: "Paid sick leave balance." + requestLabel: "Request Sick Leave" + total: 40 + isActive: true + } + ) + benefit_plan_3: vendorBenefitPlan_insert( + data: { + id: "2d8f7d4b-1f90-4d8b-8b9d-9200d8f01003" + vendorId: "c3b25c47-0ebd-4402-a9b1-b8a875a7f71a" + title: "Training Hours" + description: "Vendor-sponsored training time." + requestLabel: "Request Training Hours" + total: 24 + isActive: true + } + ) + + # Benefits balances (remaining hours) + benefits_data_1: benefitsData_insert( + data: { + id: "aa8bf762-141e-4c69-ae15-7c5416fd1101" + vendorBenefitPlanId: "2d8f7d4b-1f90-4d8b-8b9d-9200d8f01001" + staffId: "633df3ce-b92c-473f-90d8-38dd027fdf57" + current: 52 + } + ) + benefits_data_2: benefitsData_insert( + data: { + id: "aa8bf762-141e-4c69-ae15-7c5416fd1102" + vendorBenefitPlanId: "2d8f7d4b-1f90-4d8b-8b9d-9200d8f01002" + staffId: "633df3ce-b92c-473f-90d8-38dd027fdf57" + current: 30 + } + ) + benefits_data_3: benefitsData_insert( + data: { + id: "aa8bf762-141e-4c69-ae15-7c5416fd1103" + vendorBenefitPlanId: "2d8f7d4b-1f90-4d8b-8b9d-9200d8f01003" + staffId: "633df3ce-b92c-473f-90d8-38dd027fdf57" + current: 16 + } + ) + benefits_data_4: benefitsData_insert( + data: { + id: "aa8bf762-141e-4c69-ae15-7c5416fd1104" + vendorBenefitPlanId: "2d8f7d4b-1f90-4d8b-8b9d-9200d8f01001" + staffId: "e7f8a9b0-c1d2-4e5f-a6b7-c8d9e0f1a2b3" + current: 64 + } + ) + benefits_data_5: benefitsData_insert( + data: { + id: "aa8bf762-141e-4c69-ae15-7c5416fd1105" + vendorBenefitPlanId: "2d8f7d4b-1f90-4d8b-8b9d-9200d8f01002" + staffId: "e7f8a9b0-c1d2-4e5f-a6b7-c8d9e0f1a2b3" + current: 36 + } + ) + benefits_data_6: benefitsData_insert( + data: { + id: "aa8bf762-141e-4c69-ae15-7c5416fd1106" + vendorBenefitPlanId: "2d8f7d4b-1f90-4d8b-8b9d-9200d8f01003" + staffId: "e7f8a9b0-c1d2-4e5f-a6b7-c8d9e0f1a2b3" + current: 20 + } + ) + + # Bank accounts (client + staff) + account_1: account_insert( + data: { + id: "ed6fd954-3f25-4ab7-b44f-2f03f1ca5101" + bank: "Bank of America" + type: CHECKING + last4: "4455" + isPrimary: true + accountNumber: "883104455" + routeNumber: "121000358" + ownerId: "ef69e942-d6e5-48e5-a8bc-69d3faa63b2f" + } + ) + account_2: account_insert( + data: { + id: "ed6fd954-3f25-4ab7-b44f-2f03f1ca5102" + bank: "Chase" + type: CHECKING + last4: "3301" + isPrimary: true + accountNumber: "009813301" + routeNumber: "322271627" + ownerId: "633df3ce-b92c-473f-90d8-38dd027fdf57" + } + ) + account_3: account_insert( + data: { + id: "ed6fd954-3f25-4ab7-b44f-2f03f1ca5103" + bank: "Wells Fargo" + type: SAVINGS + last4: "7812" + isPrimary: true + accountNumber: "114927812" + routeNumber: "121042882" + ownerId: "e7f8a9b0-c1d2-4e5f-a6b7-c8d9e0f1a2b3" + } + ) + # Documents document_1: document_insert( data: { @@ -575,6 +777,41 @@ mutation seedAll @transaction { verificationId: "verif_staff3_id_001" } ) + staff_document_5: staffDocument_insert( + data: { + id: "bf01f474-2f2d-40f5-8ca7-0b6a1e52dd8a" + staffId: "e7f8a9b0-c1d2-4e5f-a6b7-c8d9e0f1a2b3" + staffName: "Test Staff" + documentId: "9fd8b1bb-63b4-4480-a53e-c65ae5f03ea8" + status: VERIFIED + documentUrl: "https://storage.googleapis.com/krow-workforce-dev/docs/staff-7/w4.pdf" + verificationId: "verif_staff7_w4_001" + verifiedAt: "2026-02-20T17:15:00Z" + } + ) + staff_document_6: staffDocument_insert( + data: { + id: "bf01f474-2f2d-40f5-8ca7-0b6a1e52dd8b" + staffId: "e7f8a9b0-c1d2-4e5f-a6b7-c8d9e0f1a2b3" + staffName: "Test Staff" + documentId: "f3389b80-9407-45ca-bdbe-6aeb873f2f5d" + status: VERIFIED + documentUrl: "https://storage.googleapis.com/krow-workforce-dev/docs/staff-7/direct-deposit.pdf" + verificationId: "verif_staff7_dd_001" + verifiedAt: "2026-02-20T18:00:00Z" + } + ) + staff_document_7: staffDocument_insert( + data: { + id: "bf01f474-2f2d-40f5-8ca7-0b6a1e52dd8c" + staffId: "e7f8a9b0-c1d2-4e5f-a6b7-c8d9e0f1a2b3" + staffName: "Test Staff" + documentId: "2eb0f5e0-b5f7-4ec2-8994-ae5b12ec8f57" + status: PENDING + documentUrl: "https://storage.googleapis.com/krow-workforce-dev/docs/staff-7/id-copy.png" + verificationId: "verif_staff7_id_001" + } + ) # Certificates certificate_1: certificate_insert( @@ -618,6 +855,34 @@ mutation seedAll @transaction { certificateNumber: "RBS-STAFF2-1103" } ) + certificate_4: certificate_insert( + data: { + id: "67b9ec44-6f9b-4f3a-9c8d-23f370883a90" + staffId: "e7f8a9b0-c1d2-4e5f-a6b7-c8d9e0f1a2b3" + certificationType: BACKGROUND_CHECK + name: "Background Check Clearance" + status: CURRENT + issuer: "Checkr" + fileUrl: "https://storage.googleapis.com/krow-workforce-dev/certs/staff-7/background.pdf" + validationStatus: APPROVED + certificateNumber: "BG-STAFF7-2026" + expiry: "2027-02-20T00:00:00Z" + } + ) + certificate_5: certificate_insert( + data: { + id: "67b9ec44-6f9b-4f3a-9c8d-23f370883a91" + staffId: "e7f8a9b0-c1d2-4e5f-a6b7-c8d9e0f1a2b3" + certificationType: FOOD_HANDLER + name: "Food Handler Card" + status: CURRENT + issuer: "ServSafe" + fileUrl: "https://storage.googleapis.com/krow-workforce-dev/certs/staff-7/food-handler.pdf" + validationStatus: AI_VERIFIED + certificateNumber: "FH-STAFF7-2204" + expiry: "2026-12-30T00:00:00Z" + } + ) # Orders (20 total) order_01: order_insert( @@ -900,6 +1165,90 @@ mutation seedAll @transaction { total: 224 } ) + order_21: order_insert( + data: { + id: "f201e540-70cd-4e49-b3b1-4c85df9a2101" + vendorId: "c3b25c47-0ebd-4402-a9b1-b8a875a7f71a" + businessId: "ef69e942-d6e5-48e5-a8bc-69d3faa63b2f" + orderType: ONE_TIME + status: PARTIAL_STAFFED + eventName: "Client Demo Breakfast Support" + teamHubId: "22a0b119-e6dc-4011-9043-d857cd4c12f3" + date: "2026-03-04T05:00:00Z" + requested: 2 + total: 320 + } + ) + order_22: order_insert( + data: { + id: "f201e540-70cd-4e49-b3b1-4c85df9a2102" + vendorId: "c3b25c47-0ebd-4402-a9b1-b8a875a7f71a" + businessId: "ef69e942-d6e5-48e5-a8bc-69d3faa63b2f" + orderType: ONE_TIME + status: PARTIAL_STAFFED + eventName: "Conference Lounge Coverage" + teamHubId: "9c8eb9c6-c186-4d55-877e-35be852c3e86" + date: "2026-03-05T05:00:00Z" + requested: 3 + total: 624 + } + ) + order_23: order_insert( + data: { + id: "f201e540-70cd-4e49-b3b1-4c85df9a2103" + vendorId: "c3b25c47-0ebd-4402-a9b1-b8a875a7f71a" + businessId: "ef69e942-d6e5-48e5-a8bc-69d3faa63b2f" + orderType: ONE_TIME + status: FULLY_STAFFED + eventName: "Executive Lunch Prep" + teamHubId: "75c70d83-1680-4b28-ab61-2fe64a74fc5f" + date: "2026-03-06T05:00:00Z" + requested: 2 + total: 288 + } + ) + order_24: order_insert( + data: { + id: "f201e540-70cd-4e49-b3b1-4c85df9a2104" + vendorId: "c3b25c47-0ebd-4402-a9b1-b8a875a7f71a" + businessId: "ef69e942-d6e5-48e5-a8bc-69d3faa63b2f" + orderType: ONE_TIME + status: COMPLETED + eventName: "Late Shift Cleanup" + teamHubId: "22a0b119-e6dc-4011-9043-d857cd4c12f3" + date: "2026-03-03T05:00:00Z" + requested: 1 + total: 208 + } + ) + order_25: order_insert( + data: { + id: "f201e540-70cd-4e49-b3b1-4c85df9a2105" + vendorId: "c3b25c47-0ebd-4402-a9b1-b8a875a7f71a" + businessId: "ef69e942-d6e5-48e5-a8bc-69d3faa63b2f" + orderType: ONE_TIME + status: POSTED + eventName: "Sunday Brunch Standby" + teamHubId: "9c8eb9c6-c186-4d55-877e-35be852c3e86" + date: "2026-03-08T05:00:00Z" + requested: 1 + total: 120 + } + ) + order_26: order_insert( + data: { + id: "f201e540-70cd-4e49-b3b1-4c85df9a2106" + vendorId: "c3b25c47-0ebd-4402-a9b1-b8a875a7f71a" + businessId: "ef69e942-d6e5-48e5-a8bc-69d3faa63b2f" + orderType: ONE_TIME + status: FULLY_STAFFED + eventName: "Security Night Rotation" + teamHubId: "75c70d83-1680-4b28-ab61-2fe64a74fc5f" + date: "2026-03-10T05:00:00Z" + requested: 1 + total: 280 + } + ) # Shifts (1 per order) shift_01: shift_insert( @@ -1362,6 +1711,148 @@ mutation seedAll @transaction { filled: 0 } ) + shift_21: shift_insert( + data: { + id: "ea729213-1652-4e4b-95cb-a7d5c1a1e301" + title: "Client Demo Breakfast Support Shift" + orderId: "f201e540-70cd-4e49-b3b1-4c85df9a2101" + date: "2026-03-04T05:00:00Z" + startTime: "2026-03-04T14:00:00Z" + endTime: "2026-03-04T22:00:00Z" + hours: 8 + cost: 320 + locationAddress: "5000 San Jose Street, Granada Hills, CA, USA" + city: "Los Angeles" + state: "CA" + street: "San Jose Street" + country: "US" + placeId: "Eiw1MDAwIFNhbiBKb3NlIFN0cmVldCwgR3JhbmFkYSBIaWxscywgQ0EsIFVTQSIuKiwKFAoSCYNJZBTdmsKAEddGOfBj8LvTEhQKEglnNXI0zZrCgBEjR6om62lcVw" + latitude: 34.2611486 + longitude: -118.5010287 + status: IN_PROGRESS + workersNeeded: 2 + filled: 1 + filledAt: "2026-03-03T20:00:00Z" + } + ) + shift_22: shift_insert( + data: { + id: "ea729213-1652-4e4b-95cb-a7d5c1a1e302" + title: "Conference Lounge Coverage Shift" + orderId: "f201e540-70cd-4e49-b3b1-4c85df9a2102" + date: "2026-03-05T05:00:00Z" + startTime: "2026-03-05T15:00:00Z" + endTime: "2026-03-05T23:00:00Z" + hours: 8 + cost: 624 + locationAddress: "4000 San Jose Street, Granada Hills, CA, USA" + city: "Los Angeles" + state: "CA" + street: "San Jose Street" + country: "US" + placeId: "Eiw0MDAwIFNhbiBKb3NlIFN0cmVldCwgR3JhbmFkYSBIaWxscywgQ0EsIFVTQSIuKiwKFAoSCYNJZBTdmsKAEddGOfBj8LvTEhQKEglnNXI0zZrCgBEjR6om62lcVw" + latitude: 34.2611486 + longitude: -118.5010287 + status: OPEN + workersNeeded: 3 + filled: 2 + } + ) + shift_23: shift_insert( + data: { + id: "ea729213-1652-4e4b-95cb-a7d5c1a1e303" + title: "Executive Lunch Prep Shift" + orderId: "f201e540-70cd-4e49-b3b1-4c85df9a2103" + date: "2026-03-06T05:00:00Z" + startTime: "2026-03-06T16:00:00Z" + endTime: "2026-03-06T22:00:00Z" + hours: 6 + cost: 288 + locationAddress: "6800 San Jose Street, Granada Hills, CA, USA" + city: "Los Angeles" + state: "CA" + street: "San Jose Street" + country: "US" + placeId: "Eiw2ODAwIFNhbiBKb3NlIFN0cmVldCwgR3JhbmFkYSBIaWxscywgQ0EsIFVTQSIuKiwKFAoSCYNJZBTdmsKAEddGOfBj8LvTEhQKEglnNXI0zZrCgBEjR6om62lcVw" + latitude: 34.2611486 + longitude: -118.5010287 + status: FILLED + workersNeeded: 2 + filled: 2 + filledAt: "2026-03-04T18:10:00Z" + } + ) + shift_24: shift_insert( + data: { + id: "ea729213-1652-4e4b-95cb-a7d5c1a1e304" + title: "Late Shift Cleanup Shift" + orderId: "f201e540-70cd-4e49-b3b1-4c85df9a2104" + date: "2026-03-03T05:00:00Z" + startTime: "2026-03-03T14:00:00Z" + endTime: "2026-03-03T22:00:00Z" + hours: 8 + cost: 208 + locationAddress: "5000 San Jose Street, Granada Hills, CA, USA" + city: "Los Angeles" + state: "CA" + street: "San Jose Street" + country: "US" + placeId: "Eiw1MDAwIFNhbiBKb3NlIFN0cmVldCwgR3JhbmFkYSBIaWxscywgQ0EsIFVTQSIuKiwKFAoSCYNJZBTdmsKAEddGOfBj8LvTEhQKEglnNXI0zZrCgBEjR6om62lcVw" + latitude: 34.2611486 + longitude: -118.5010287 + status: COMPLETED + workersNeeded: 1 + filled: 1 + filledAt: "2026-03-02T22:30:00Z" + } + ) + shift_25: shift_insert( + data: { + id: "ea729213-1652-4e4b-95cb-a7d5c1a1e305" + title: "Sunday Brunch Standby Shift" + orderId: "f201e540-70cd-4e49-b3b1-4c85df9a2105" + date: "2026-03-08T05:00:00Z" + startTime: "2026-03-08T15:00:00Z" + endTime: "2026-03-08T20:00:00Z" + hours: 5 + cost: 120 + locationAddress: "4000 San Jose Street, Granada Hills, CA, USA" + city: "Los Angeles" + state: "CA" + street: "San Jose Street" + country: "US" + placeId: "Eiw0MDAwIFNhbiBKb3NlIFN0cmVldCwgR3JhbmFkYSBIaWxscywgQ0EsIFVTQSIuKiwKFAoSCYNJZBTdmsKAEddGOfBj8LvTEhQKEglnNXI0zZrCgBEjR6om62lcVw" + latitude: 34.2611486 + longitude: -118.5010287 + status: OPEN + workersNeeded: 1 + filled: 0 + } + ) + shift_26: shift_insert( + data: { + id: "ea729213-1652-4e4b-95cb-a7d5c1a1e306" + title: "Security Night Rotation Shift" + orderId: "f201e540-70cd-4e49-b3b1-4c85df9a2106" + date: "2026-03-10T05:00:00Z" + startTime: "2026-03-10T14:00:00Z" + endTime: "2026-03-11T00:00:00Z" + hours: 10 + cost: 280 + locationAddress: "6800 San Jose Street, Granada Hills, CA, USA" + city: "Los Angeles" + state: "CA" + street: "San Jose Street" + country: "US" + placeId: "Eiw2ODAwIFNhbiBKb3NlIFN0cmVldCwgR3JhbmFkYSBIaWxscywgQ0EsIFVTQSIuKiwKFAoSCYNJZBTdmsKAEddGOfBj8LvTEhQKEglnNXI0zZrCgBEjR6om62lcVw" + latitude: 34.2611486 + longitude: -118.5010287 + status: FILLED + workersNeeded: 1 + filled: 1 + filledAt: "2026-03-09T19:00:00Z" + } + ) # Shift Roles (1 per shift) shift_role_01: shiftRole_insert( @@ -1644,6 +2135,90 @@ mutation seedAll @transaction { totalValue: 224 } ) + shift_role_21: shiftRole_insert( + data: { + id: "360616bf-8083-4dff-8d22-82380304d901" + shiftId: "ea729213-1652-4e4b-95cb-a7d5c1a1e301" + roleId: "73fdb09b-ecbd-402e-8eb4-e7d79237d017" + count: 2 + assigned: 1 + startTime: "2026-03-04T14:00:00Z" + endTime: "2026-03-04T22:00:00Z" + hours: 8 + breakType: MIN_30 + totalValue: 320 + } + ) + shift_role_22: shiftRole_insert( + data: { + id: "360616bf-8083-4dff-8d22-82380304d902" + shiftId: "ea729213-1652-4e4b-95cb-a7d5c1a1e302" + roleId: "7de956ce-743b-4271-b826-73313a5f07f5" + count: 3 + assigned: 2 + startTime: "2026-03-05T15:00:00Z" + endTime: "2026-03-05T23:00:00Z" + hours: 8 + breakType: MIN_30 + totalValue: 624 + } + ) + shift_role_23: shiftRole_insert( + data: { + id: "360616bf-8083-4dff-8d22-82380304d903" + shiftId: "ea729213-1652-4e4b-95cb-a7d5c1a1e303" + roleId: "e51f3553-f2ee-400b-91e6-92b534239697" + count: 2 + assigned: 2 + startTime: "2026-03-06T16:00:00Z" + endTime: "2026-03-06T22:00:00Z" + hours: 6 + breakType: MIN_15 + totalValue: 288 + } + ) + shift_role_24: shiftRole_insert( + data: { + id: "360616bf-8083-4dff-8d22-82380304d904" + shiftId: "ea729213-1652-4e4b-95cb-a7d5c1a1e304" + roleId: "7de956ce-743b-4271-b826-73313a5f07f5" + count: 1 + assigned: 1 + startTime: "2026-03-03T14:00:00Z" + endTime: "2026-03-03T22:00:00Z" + hours: 8 + breakType: MIN_30 + totalValue: 208 + } + ) + shift_role_25: shiftRole_insert( + data: { + id: "360616bf-8083-4dff-8d22-82380304d905" + shiftId: "ea729213-1652-4e4b-95cb-a7d5c1a1e305" + roleId: "e51f3553-f2ee-400b-91e6-92b534239697" + count: 1 + assigned: 0 + startTime: "2026-03-08T15:00:00Z" + endTime: "2026-03-08T20:00:00Z" + hours: 5 + breakType: MIN_15 + totalValue: 120 + } + ) + shift_role_26: shiftRole_insert( + data: { + id: "360616bf-8083-4dff-8d22-82380304d906" + shiftId: "ea729213-1652-4e4b-95cb-a7d5c1a1e306" + roleId: "67ab1dcb-5b54-4dd9-aeb5-9cc58bdda0ed" + count: 1 + assigned: 1 + startTime: "2026-03-10T14:00:00Z" + endTime: "2026-03-11T00:00:00Z" + hours: 10 + breakType: MIN_30 + totalValue: 280 + } + ) # Applications application_01: application_insert( @@ -1836,6 +2411,80 @@ mutation seedAll @transaction { origin: STAFF } ) + application_20: application_insert( + data: { + id: "b8c4b723-346d-4bcd-9667-35944ba5dbbe" + shiftId: "ea729213-1652-4e4b-95cb-a7d5c1a1e301" + staffId: "e7f8a9b0-c1d2-4e5f-a6b7-c8d9e0f1a2b3" + roleId: "73fdb09b-ecbd-402e-8eb4-e7d79237d017" + status: CHECKED_IN + checkInTime: "2026-03-04T14:02:00Z" + origin: STAFF + } + ) + application_21: application_insert( + data: { + id: "b8c4b723-346d-4bcd-9667-35944ba5dbbf" + shiftId: "ea729213-1652-4e4b-95cb-a7d5c1a1e304" + staffId: "e7f8a9b0-c1d2-4e5f-a6b7-c8d9e0f1a2b3" + roleId: "7de956ce-743b-4271-b826-73313a5f07f5" + status: COMPLETED + checkInTime: "2026-03-03T14:05:00Z" + checkOutTime: "2026-03-03T22:01:00Z" + origin: STAFF + } + ) + application_22: application_insert( + data: { + id: "b8c4b723-346d-4bcd-9667-35944ba5dbc0" + shiftId: "ea729213-1652-4e4b-95cb-a7d5c1a1e303" + staffId: "633df3ce-b92c-473f-90d8-38dd027fdf57" + roleId: "e51f3553-f2ee-400b-91e6-92b534239697" + status: CONFIRMED + origin: STAFF + } + ) + application_23: application_insert( + data: { + id: "b8c4b723-346d-4bcd-9667-35944ba5dbc1" + shiftId: "ea729213-1652-4e4b-95cb-a7d5c1a1e302" + staffId: "9631581a-1601-4e06-8e5e-600e9f305bcf" + roleId: "7de956ce-743b-4271-b826-73313a5f07f5" + status: LATE + checkInTime: "2026-03-05T15:25:00Z" + origin: STAFF + } + ) + application_24: application_insert( + data: { + id: "b8c4b723-346d-4bcd-9667-35944ba5dbc2" + shiftId: "ea729213-1652-4e4b-95cb-a7d5c1a1e302" + staffId: "2b678a6d-b8cd-4d5e-95ae-f35e4569f92c" + roleId: "7de956ce-743b-4271-b826-73313a5f07f5" + status: NO_SHOW + origin: STAFF + } + ) + application_25: application_insert( + data: { + id: "b8c4b723-346d-4bcd-9667-35944ba5dbc3" + shiftId: "ea729213-1652-4e4b-95cb-a7d5c1a1e306" + staffId: "e7f8a9b0-c1d2-4e5f-a6b7-c8d9e0f1a2b3" + roleId: "67ab1dcb-5b54-4dd9-aeb5-9cc58bdda0ed" + status: CONFIRMED + origin: STAFF + } + ) + application_26: application_insert( + data: { + id: "b8c4b723-346d-4bcd-9667-35944ba5dbc4" + shiftId: "ea729213-1652-4e4b-95cb-a7d5c1a1e303" + staffId: "56d7178c-f4ab-4c50-9b1f-d6efe25ba50b" + roleId: "e51f3553-f2ee-400b-91e6-92b534239697" + status: CONFIRMED + origin: STAFF + } + ) # Invoices (for completed orders) invoice_01: invoice_insert( @@ -2030,6 +2679,91 @@ mutation seedAll @transaction { chargesCount: 1 } ) + invoice_13: invoice_insert( + data: { + id: "c23f3ed2-7fa1-43f5-88e9-4227e34cb5f1" + status: PENDING + vendorId: "c3b25c47-0ebd-4402-a9b1-b8a875a7f71a" + businessId: "ef69e942-d6e5-48e5-a8bc-69d3faa63b2f" + orderId: "f201e540-70cd-4e49-b3b1-4c85df9a2101" + shiftId: "ea729213-1652-4e4b-95cb-a7d5c1a1e301" + paymentTerms: NET_30 + invoiceNumber: "INV-2026-0013" + issueDate: "2026-03-04T05:00:00Z" + dueDate: "2026-04-03T05:00:00Z" + amount: 320 + staffCount: 2 + chargesCount: 1 + } + ) + invoice_14: invoice_insert( + data: { + id: "c23f3ed2-7fa1-43f5-88e9-4227e34cb5f2" + status: OVERDUE + vendorId: "c3b25c47-0ebd-4402-a9b1-b8a875a7f71a" + businessId: "ef69e942-d6e5-48e5-a8bc-69d3faa63b2f" + orderId: "f201e540-70cd-4e49-b3b1-4c85df9a2102" + shiftId: "ea729213-1652-4e4b-95cb-a7d5c1a1e302" + paymentTerms: NET_30 + invoiceNumber: "INV-2026-0014" + issueDate: "2026-02-20T05:00:00Z" + dueDate: "2026-03-01T05:00:00Z" + amount: 624 + staffCount: 3 + chargesCount: 1 + } + ) + invoice_15: invoice_insert( + data: { + id: "c23f3ed2-7fa1-43f5-88e9-4227e34cb5f3" + status: APPROVED + vendorId: "c3b25c47-0ebd-4402-a9b1-b8a875a7f71a" + businessId: "ef69e942-d6e5-48e5-a8bc-69d3faa63b2f" + orderId: "f201e540-70cd-4e49-b3b1-4c85df9a2103" + shiftId: "ea729213-1652-4e4b-95cb-a7d5c1a1e303" + paymentTerms: NET_30 + invoiceNumber: "INV-2026-0015" + issueDate: "2026-03-06T05:00:00Z" + dueDate: "2026-04-05T05:00:00Z" + amount: 288 + staffCount: 2 + chargesCount: 1 + } + ) + invoice_16: invoice_insert( + data: { + id: "c23f3ed2-7fa1-43f5-88e9-4227e34cb5f4" + status: PAID + vendorId: "c3b25c47-0ebd-4402-a9b1-b8a875a7f71a" + businessId: "ef69e942-d6e5-48e5-a8bc-69d3faa63b2f" + orderId: "f201e540-70cd-4e49-b3b1-4c85df9a2104" + shiftId: "ea729213-1652-4e4b-95cb-a7d5c1a1e304" + paymentTerms: NET_30 + invoiceNumber: "INV-2026-0016" + issueDate: "2026-03-03T05:00:00Z" + dueDate: "2026-04-02T05:00:00Z" + amount: 208 + staffCount: 1 + chargesCount: 1 + } + ) + invoice_17: invoice_insert( + data: { + id: "c23f3ed2-7fa1-43f5-88e9-4227e34cb5f5" + status: PENDING_REVIEW + vendorId: "c3b25c47-0ebd-4402-a9b1-b8a875a7f71a" + businessId: "ef69e942-d6e5-48e5-a8bc-69d3faa63b2f" + orderId: "f201e540-70cd-4e49-b3b1-4c85df9a2106" + shiftId: "ea729213-1652-4e4b-95cb-a7d5c1a1e306" + paymentTerms: NET_30 + invoiceNumber: "INV-2026-0017" + issueDate: "2026-03-10T05:00:00Z" + dueDate: "2026-04-09T05:00:00Z" + amount: 280 + staffCount: 1 + chargesCount: 1 + } + ) # Recent Payments (only for PAID invoices) recent_payment_01: recentPayment_insert( @@ -2062,6 +2796,46 @@ mutation seedAll @transaction { invoiceId: "ba0529be-7906-417f-8ec7-c866d0633fee" } ) + recent_payment_04: recentPayment_insert( + data: { + id: "4d45192e-34fe-4e07-a4f9-708e7591a9b6" + workedTime: "8h" + status: PAID + staffId: "e7f8a9b0-c1d2-4e5f-a6b7-c8d9e0f1a2b3" + applicationId: "b8c4b723-346d-4bcd-9667-35944ba5dbbf" + invoiceId: "c23f3ed2-7fa1-43f5-88e9-4227e34cb5f4" + } + ) + recent_payment_05: recentPayment_insert( + data: { + id: "4d45192e-34fe-4e07-a4f9-708e7591a9b7" + workedTime: "8h" + status: PENDING + staffId: "e7f8a9b0-c1d2-4e5f-a6b7-c8d9e0f1a2b3" + applicationId: "b8c4b723-346d-4bcd-9667-35944ba5dbbe" + invoiceId: "c23f3ed2-7fa1-43f5-88e9-4227e34cb5f1" + } + ) + recent_payment_06: recentPayment_insert( + data: { + id: "4d45192e-34fe-4e07-a4f9-708e7591a9b8" + workedTime: "6h" + status: PENDING + staffId: "633df3ce-b92c-473f-90d8-38dd027fdf57" + applicationId: "b8c4b723-346d-4bcd-9667-35944ba5dbc0" + invoiceId: "c23f3ed2-7fa1-43f5-88e9-4227e34cb5f3" + } + ) + recent_payment_07: recentPayment_insert( + data: { + id: "4d45192e-34fe-4e07-a4f9-708e7591a9b9" + workedTime: "6h" + status: PENDING + staffId: "56d7178c-f4ab-4c50-9b1f-d6efe25ba50b" + applicationId: "b8c4b723-346d-4bcd-9667-35944ba5dbc4" + invoiceId: "c23f3ed2-7fa1-43f5-88e9-4227e34cb5f3" + } + ) # Attire Options (Required) attire_1: attireOption_insert( @@ -2220,5 +2994,54 @@ mutation seedAll @transaction { vendorId: "c3b25c47-0ebd-4402-a9b1-b8a875a7f71a" } ) + staff_attire_1: staffAttire_insert( + data: { + staffId: "e7f8a9b0-c1d2-4e5f-a6b7-c8d9e0f1a2b3" + attireOptionId: "4bce6592-e38e-4d90-a478-d1ce0f286146" + verificationStatus: APPROVED + verificationPhotoUrl: "https://storage.googleapis.com/krow-workforce-dev/attire/staff-7/non-slip-shoes.jpg" + verificationId: "attire_verif_staff7_001" + verifiedAt: "2026-03-01T17:00:00Z" + } + ) + staff_attire_2: staffAttire_insert( + data: { + staffId: "e7f8a9b0-c1d2-4e5f-a6b7-c8d9e0f1a2b3" + attireOptionId: "786e9761-b398-42bd-b363-91a40938864e" + verificationStatus: APPROVED + verificationPhotoUrl: "https://storage.googleapis.com/krow-workforce-dev/attire/staff-7/black-pants.jpg" + verificationId: "attire_verif_staff7_002" + verifiedAt: "2026-03-01T17:05:00Z" + } + ) + staff_attire_3: staffAttire_insert( + data: { + staffId: "e7f8a9b0-c1d2-4e5f-a6b7-c8d9e0f1a2b3" + attireOptionId: "bbff61b3-3f99-4637-9a2f-1d4c6fa61517" + verificationStatus: PROCESSING + verificationPhotoUrl: "https://storage.googleapis.com/krow-workforce-dev/attire/staff-7/white-button-up.jpg" + verificationId: "attire_verif_staff7_003" + } + ) + staff_attire_4: staffAttire_insert( + data: { + staffId: "633df3ce-b92c-473f-90d8-38dd027fdf57" + attireOptionId: "4bce6592-e38e-4d90-a478-d1ce0f286146" + verificationStatus: APPROVED + verificationPhotoUrl: "https://storage.googleapis.com/krow-workforce-dev/attire/staff-1/non-slip-shoes.jpg" + verificationId: "attire_verif_staff1_001" + verifiedAt: "2026-02-21T16:20:00Z" + } + ) + staff_attire_5: staffAttire_insert( + data: { + staffId: "633df3ce-b92c-473f-90d8-38dd027fdf57" + attireOptionId: "17b135e6-b8f0-4541-b12b-505e95de31ef" + verificationStatus: APPROVED + verificationPhotoUrl: "https://storage.googleapis.com/krow-workforce-dev/attire/staff-1/black-socks.jpg" + verificationId: "attire_verif_staff1_002" + verifiedAt: "2026-02-21T16:23:00Z" + } + ) } -#v.3 +#v.4 From a465b04e9a1d56a55b76a5682ba90eabb72d45cc Mon Sep 17 00:00:00 2001 From: zouantchaw <44246692+zouantchaw@users.noreply.github.com> Date: Wed, 11 Mar 2026 17:02:56 +0100 Subject: [PATCH 05/21] Ignore local skills artifacts --- .gitignore | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.gitignore b/.gitignore index eb271963..ef614643 100644 --- a/.gitignore +++ b/.gitignore @@ -182,6 +182,8 @@ internal/launchpad/prototypes-src/ # Temporary migration artifacts _legacy/ krow-workforce-export-latest/ +skills/ +skills-lock.json # Data Connect Generated SDKs (Explicit) apps/mobile/packages/data_connect/lib/src/dataconnect_generated/ From bc068373e94b46373bf8f74fe68c31b912a19578 Mon Sep 17 00:00:00 2001 From: zouantchaw <44246692+zouantchaw@users.noreply.github.com> Date: Wed, 11 Mar 2026 17:02:56 +0100 Subject: [PATCH 06/21] Ignore local skills artifacts --- .gitignore | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.gitignore b/.gitignore index eb271963..ef614643 100644 --- a/.gitignore +++ b/.gitignore @@ -182,6 +182,8 @@ internal/launchpad/prototypes-src/ # Temporary migration artifacts _legacy/ krow-workforce-export-latest/ +skills/ +skills-lock.json # Data Connect Generated SDKs (Explicit) apps/mobile/packages/data_connect/lib/src/dataconnect_generated/ From fe43ff23cf470f03b17642d36b83e2dc22df7e0c Mon Sep 17 00:00:00 2001 From: zouantchaw <44246692+zouantchaw@users.noreply.github.com> Date: Wed, 11 Mar 2026 18:23:55 +0100 Subject: [PATCH 07/21] feat(backend): implement v2 domain slice and live smoke --- backend/command-api/package.json | 5 +- backend/command-api/scripts/live-smoke-v2.mjs | 348 ++++ .../scripts/migrate-idempotency.mjs | 4 +- .../command-api/scripts/migrate-v2-schema.mjs | 69 + .../command-api/scripts/seed-v2-demo-data.mjs | 600 +++++++ .../command-api/scripts/v2-demo-fixture.mjs | 162 ++ .../sql/v2/001_v2_domain_foundation.sql | 639 +++++++ backend/command-api/src/app.js | 4 +- .../src/contracts/commands/attendance.js | 14 + .../src/contracts/commands/favorite-staff.js | 7 + .../src/contracts/commands/order-cancel.js | 8 + .../src/contracts/commands/order-create.js | 57 + .../src/contracts/commands/order-update.js | 35 + .../src/contracts/commands/shift-accept.js | 8 + .../contracts/commands/shift-assign-staff.js | 10 + .../contracts/commands/shift-status-change.js | 17 + .../src/contracts/commands/staff-review.js | 11 + backend/command-api/src/routes/commands.js | 262 ++- backend/command-api/src/routes/health.js | 30 + .../src/services/command-service.js | 1553 +++++++++++++++++ backend/command-api/src/services/db.js | 94 + .../src/services/idempotency-store.js | 20 +- backend/command-api/test/app.test.js | 76 +- backend/query-api/package-lock.json | 138 ++ backend/query-api/package.json | 1 + backend/query-api/src/app.js | 4 +- backend/query-api/src/middleware/auth.js | 45 + backend/query-api/src/routes/health.js | 30 + backend/query-api/src/routes/query.js | 138 ++ backend/query-api/src/services/db.js | 72 + .../query-api/src/services/firebase-auth.js | 13 + backend/query-api/src/services/policy.js | 5 + .../query-api/src/services/query-service.js | 285 +++ backend/query-api/test/app.test.js | 102 ++ docs/MILESTONES/M4/planning/m4-api-catalog.md | 3 +- .../M4/planning/m4-core-api-frontend-guide.md | 21 +- .../M4/planning/m4-target-schema-blueprint.md | 29 +- .../m4-target-schema-models-and-keys.md | 12 +- .../m4-v2-frontend-migration-guide.md | 303 ++++ makefiles/backend.mk | 56 +- 40 files changed, 5191 insertions(+), 99 deletions(-) create mode 100644 backend/command-api/scripts/live-smoke-v2.mjs create mode 100644 backend/command-api/scripts/migrate-v2-schema.mjs create mode 100644 backend/command-api/scripts/seed-v2-demo-data.mjs create mode 100644 backend/command-api/scripts/v2-demo-fixture.mjs create mode 100644 backend/command-api/sql/v2/001_v2_domain_foundation.sql create mode 100644 backend/command-api/src/contracts/commands/attendance.js create mode 100644 backend/command-api/src/contracts/commands/favorite-staff.js create mode 100644 backend/command-api/src/contracts/commands/order-cancel.js create mode 100644 backend/command-api/src/contracts/commands/order-create.js create mode 100644 backend/command-api/src/contracts/commands/order-update.js create mode 100644 backend/command-api/src/contracts/commands/shift-accept.js create mode 100644 backend/command-api/src/contracts/commands/shift-assign-staff.js create mode 100644 backend/command-api/src/contracts/commands/shift-status-change.js create mode 100644 backend/command-api/src/contracts/commands/staff-review.js create mode 100644 backend/command-api/src/services/command-service.js create mode 100644 backend/command-api/src/services/db.js create mode 100644 backend/query-api/src/middleware/auth.js create mode 100644 backend/query-api/src/routes/query.js create mode 100644 backend/query-api/src/services/db.js create mode 100644 backend/query-api/src/services/firebase-auth.js create mode 100644 backend/query-api/src/services/policy.js create mode 100644 backend/query-api/src/services/query-service.js create mode 100644 docs/MILESTONES/M4/planning/m4-v2-frontend-migration-guide.md diff --git a/backend/command-api/package.json b/backend/command-api/package.json index c47230cf..7d8ce23c 100644 --- a/backend/command-api/package.json +++ b/backend/command-api/package.json @@ -9,7 +9,10 @@ "scripts": { "start": "node src/server.js", "test": "node --test", - "migrate:idempotency": "node scripts/migrate-idempotency.mjs" + "migrate:idempotency": "node scripts/migrate-idempotency.mjs", + "migrate:v2-schema": "node scripts/migrate-v2-schema.mjs", + "seed:v2-demo": "node scripts/seed-v2-demo-data.mjs", + "smoke:v2-live": "node scripts/live-smoke-v2.mjs" }, "dependencies": { "express": "^4.21.2", diff --git a/backend/command-api/scripts/live-smoke-v2.mjs b/backend/command-api/scripts/live-smoke-v2.mjs new file mode 100644 index 00000000..ae08ba29 --- /dev/null +++ b/backend/command-api/scripts/live-smoke-v2.mjs @@ -0,0 +1,348 @@ +import assert from 'node:assert/strict'; +import { V2DemoFixture as fixture } from './v2-demo-fixture.mjs'; + +const firebaseApiKey = process.env.FIREBASE_API_KEY || 'AIzaSyBqRtZPMGU-Sz5x5UnRrunKu5NSWYyPRn8'; +const demoEmail = process.env.V2_SMOKE_EMAIL || fixture.users.businessOwner.email; +const demoPassword = process.env.V2_SMOKE_PASSWORD || 'Demo2026!'; +const commandBaseUrl = process.env.COMMAND_API_BASE_URL || 'https://krow-command-api-v2-e3g6witsvq-uc.a.run.app'; +const queryBaseUrl = process.env.QUERY_API_BASE_URL || 'https://krow-query-api-v2-e3g6witsvq-uc.a.run.app'; + +async function signInWithPassword() { + const response = await fetch( + `https://identitytoolkit.googleapis.com/v1/accounts:signInWithPassword?key=${firebaseApiKey}`, + { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify({ + email: demoEmail, + password: demoPassword, + returnSecureToken: true, + }), + } + ); + + const payload = await response.json(); + if (!response.ok) { + throw new Error(`Firebase sign-in failed: ${JSON.stringify(payload)}`); + } + + return { + idToken: payload.idToken, + localId: payload.localId, + }; +} + +async function apiCall(baseUrl, path, { + method = 'GET', + token, + idempotencyKey, + body, + expectedStatus = 200, +} = {}) { + const headers = {}; + if (token) { + headers.Authorization = `Bearer ${token}`; + } + if (idempotencyKey) { + headers['Idempotency-Key'] = idempotencyKey; + } + if (body !== undefined) { + headers['Content-Type'] = 'application/json'; + } + + const response = await fetch(`${baseUrl}${path}`, { + method, + headers, + body: body === undefined ? undefined : JSON.stringify(body), + }); + + const text = await response.text(); + const payload = text ? JSON.parse(text) : {}; + + if (response.status !== expectedStatus) { + throw new Error(`${method} ${path} expected ${expectedStatus}, got ${response.status}: ${text}`); + } + + return payload; +} + +function uniqueKey(prefix) { + return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`; +} + +function logStep(step, payload) { + // eslint-disable-next-line no-console + console.log(`[live-smoke-v2] ${step}: ${JSON.stringify(payload)}`); +} + +async function main() { + const auth = await signInWithPassword(); + assert.equal(auth.localId, fixture.users.businessOwner.id); + logStep('auth.ok', { uid: auth.localId, email: demoEmail }); + + const listOrders = await apiCall( + queryBaseUrl, + `/query/tenants/${fixture.tenant.id}/orders`, + { token: auth.idToken } + ); + assert.ok(Array.isArray(listOrders.items)); + assert.ok(listOrders.items.some((item) => item.id === fixture.orders.open.id)); + logStep('orders.list.ok', { count: listOrders.items.length }); + + const openOrderDetail = await apiCall( + queryBaseUrl, + `/query/tenants/${fixture.tenant.id}/orders/${fixture.orders.open.id}`, + { token: auth.idToken } + ); + assert.equal(openOrderDetail.id, fixture.orders.open.id); + assert.equal(openOrderDetail.shifts[0].id, fixture.shifts.open.id); + logStep('orders.detail.ok', { orderId: openOrderDetail.id, shiftCount: openOrderDetail.shifts.length }); + + const favoriteResult = await apiCall( + commandBaseUrl, + `/commands/businesses/${fixture.business.id}/favorite-staff`, + { + method: 'POST', + token: auth.idToken, + idempotencyKey: uniqueKey('favorite'), + body: { + tenantId: fixture.tenant.id, + staffId: fixture.staff.ana.id, + }, + } + ); + assert.equal(favoriteResult.staffId, fixture.staff.ana.id); + logStep('favorites.add.ok', favoriteResult); + + const favoriteList = await apiCall( + queryBaseUrl, + `/query/tenants/${fixture.tenant.id}/businesses/${fixture.business.id}/favorite-staff`, + { token: auth.idToken } + ); + assert.ok(favoriteList.items.some((item) => item.staffId === fixture.staff.ana.id)); + logStep('favorites.list.ok', { count: favoriteList.items.length }); + + const reviewResult = await apiCall( + commandBaseUrl, + `/commands/assignments/${fixture.assignments.completedAna.id}/reviews`, + { + method: 'POST', + token: auth.idToken, + idempotencyKey: uniqueKey('review'), + body: { + tenantId: fixture.tenant.id, + businessId: fixture.business.id, + staffId: fixture.staff.ana.id, + rating: 5, + reviewText: 'Live smoke review', + tags: ['smoke', 'reliable'], + }, + } + ); + assert.equal(reviewResult.staffId, fixture.staff.ana.id); + logStep('reviews.create.ok', reviewResult); + + const reviewSummary = await apiCall( + queryBaseUrl, + `/query/tenants/${fixture.tenant.id}/staff/${fixture.staff.ana.id}/review-summary`, + { token: auth.idToken } + ); + assert.equal(reviewSummary.staffId, fixture.staff.ana.id); + assert.ok(reviewSummary.ratingCount >= 1); + logStep('reviews.summary.ok', { ratingCount: reviewSummary.ratingCount, averageRating: reviewSummary.averageRating }); + + const assigned = await apiCall( + commandBaseUrl, + `/commands/shifts/${fixture.shifts.open.id}/assign-staff`, + { + method: 'POST', + token: auth.idToken, + idempotencyKey: uniqueKey('assign'), + body: { + tenantId: fixture.tenant.id, + shiftRoleId: fixture.shiftRoles.openBarista.id, + workforceId: fixture.workforce.ana.id, + applicationId: fixture.applications.openAna.id, + }, + } + ); + assert.equal(assigned.shiftId, fixture.shifts.open.id); + logStep('assign.ok', assigned); + + const accepted = await apiCall( + commandBaseUrl, + `/commands/shifts/${fixture.shifts.open.id}/accept`, + { + method: 'POST', + token: auth.idToken, + idempotencyKey: uniqueKey('accept'), + body: { + shiftRoleId: fixture.shiftRoles.openBarista.id, + workforceId: fixture.workforce.ana.id, + }, + } + ); + assert.ok(['ASSIGNED', 'ACCEPTED', 'CHECKED_IN', 'CHECKED_OUT', 'COMPLETED'].includes(accepted.status)); + const liveAssignmentId = accepted.assignmentId || assigned.assignmentId; + logStep('accept.ok', accepted); + + const clockIn = await apiCall( + commandBaseUrl, + '/commands/attendance/clock-in', + { + method: 'POST', + token: auth.idToken, + idempotencyKey: uniqueKey('clockin'), + body: { + assignmentId: liveAssignmentId, + sourceType: 'NFC', + sourceReference: 'smoke', + nfcTagUid: fixture.clockPoint.nfcTagUid, + deviceId: 'smoke-device', + latitude: fixture.clockPoint.latitude, + longitude: fixture.clockPoint.longitude, + accuracyMeters: 5, + }, + } + ); + assert.equal(clockIn.assignmentId, liveAssignmentId); + logStep('attendance.clockin.ok', clockIn); + + const clockOut = await apiCall( + commandBaseUrl, + '/commands/attendance/clock-out', + { + method: 'POST', + token: auth.idToken, + idempotencyKey: uniqueKey('clockout'), + body: { + assignmentId: liveAssignmentId, + sourceType: 'NFC', + sourceReference: 'smoke', + nfcTagUid: fixture.clockPoint.nfcTagUid, + deviceId: 'smoke-device', + latitude: fixture.clockPoint.latitude, + longitude: fixture.clockPoint.longitude, + accuracyMeters: 5, + }, + } + ); + assert.equal(clockOut.assignmentId, liveAssignmentId); + logStep('attendance.clockout.ok', clockOut); + + const attendance = await apiCall( + queryBaseUrl, + `/query/tenants/${fixture.tenant.id}/assignments/${liveAssignmentId}/attendance`, + { token: auth.idToken } + ); + assert.ok(Array.isArray(attendance.events)); + assert.ok(attendance.events.length >= 2); + logStep('attendance.query.ok', { eventCount: attendance.events.length, sessionStatus: attendance.sessionStatus }); + + const orderNumber = `ORD-V2-SMOKE-${Date.now()}`; + const createdOrder = await apiCall( + commandBaseUrl, + '/commands/orders/create', + { + method: 'POST', + token: auth.idToken, + idempotencyKey: uniqueKey('order-create'), + body: { + tenantId: fixture.tenant.id, + businessId: fixture.business.id, + vendorId: fixture.vendor.id, + orderNumber, + title: 'Smoke created order', + serviceType: 'EVENT', + shifts: [ + { + shiftCode: `SHIFT-${Date.now()}`, + title: 'Smoke shift', + startsAt: new Date(Date.now() + 2 * 60 * 60 * 1000).toISOString(), + endsAt: new Date(Date.now() + 6 * 60 * 60 * 1000).toISOString(), + requiredWorkers: 1, + clockPointId: fixture.clockPoint.id, + roles: [ + { + roleCode: fixture.roles.barista.code, + roleName: fixture.roles.barista.name, + workersNeeded: 1, + payRateCents: 2200, + billRateCents: 3500, + }, + ], + }, + ], + }, + } + ); + assert.equal(createdOrder.orderNumber, orderNumber); + logStep('orders.create.ok', createdOrder); + + const updatedOrder = await apiCall( + commandBaseUrl, + `/commands/orders/${createdOrder.orderId}/update`, + { + method: 'POST', + token: auth.idToken, + idempotencyKey: uniqueKey('order-update'), + body: { + tenantId: fixture.tenant.id, + title: 'Smoke updated order', + notes: 'updated during live smoke', + }, + } + ); + assert.equal(updatedOrder.orderId, createdOrder.orderId); + logStep('orders.update.ok', updatedOrder); + + const changedShift = await apiCall( + commandBaseUrl, + `/commands/shifts/${createdOrder.shiftIds[0]}/change-status`, + { + method: 'POST', + token: auth.idToken, + idempotencyKey: uniqueKey('shift-status'), + body: { + tenantId: fixture.tenant.id, + status: 'PENDING_CONFIRMATION', + reason: 'live smoke transition', + }, + } + ); + assert.equal(changedShift.status, 'PENDING_CONFIRMATION'); + logStep('shift.status.ok', changedShift); + + const cancelledOrder = await apiCall( + commandBaseUrl, + `/commands/orders/${createdOrder.orderId}/cancel`, + { + method: 'POST', + token: auth.idToken, + idempotencyKey: uniqueKey('order-cancel'), + body: { + tenantId: fixture.tenant.id, + reason: 'live smoke cleanup', + }, + } + ); + assert.equal(cancelledOrder.status, 'CANCELLED'); + logStep('orders.cancel.ok', cancelledOrder); + + const cancelledOrderDetail = await apiCall( + queryBaseUrl, + `/query/tenants/${fixture.tenant.id}/orders/${createdOrder.orderId}`, + { token: auth.idToken } + ); + assert.equal(cancelledOrderDetail.status, 'CANCELLED'); + logStep('orders.cancel.verify.ok', { orderId: cancelledOrderDetail.id, status: cancelledOrderDetail.status }); + + // eslint-disable-next-line no-console + console.log('LIVE_SMOKE_V2_OK'); +} + +main().catch((error) => { + // eslint-disable-next-line no-console + console.error(error); + process.exit(1); +}); diff --git a/backend/command-api/scripts/migrate-idempotency.mjs b/backend/command-api/scripts/migrate-idempotency.mjs index 42970b84..f7f275f6 100644 --- a/backend/command-api/scripts/migrate-idempotency.mjs +++ b/backend/command-api/scripts/migrate-idempotency.mjs @@ -3,11 +3,11 @@ import { resolve } from 'node:path'; import { fileURLToPath } from 'node:url'; import { Pool } from 'pg'; -const databaseUrl = process.env.IDEMPOTENCY_DATABASE_URL; +const databaseUrl = process.env.IDEMPOTENCY_DATABASE_URL || process.env.DATABASE_URL; if (!databaseUrl) { // eslint-disable-next-line no-console - console.error('IDEMPOTENCY_DATABASE_URL is required'); + console.error('IDEMPOTENCY_DATABASE_URL or DATABASE_URL is required'); process.exit(1); } diff --git a/backend/command-api/scripts/migrate-v2-schema.mjs b/backend/command-api/scripts/migrate-v2-schema.mjs new file mode 100644 index 00000000..eb7dc0f4 --- /dev/null +++ b/backend/command-api/scripts/migrate-v2-schema.mjs @@ -0,0 +1,69 @@ +import { readdirSync, readFileSync } from 'node:fs'; +import { resolve } from 'node:path'; +import { fileURLToPath } from 'node:url'; +import { Pool } from 'pg'; + +const databaseUrl = process.env.DATABASE_URL; + +if (!databaseUrl) { + // eslint-disable-next-line no-console + console.error('DATABASE_URL is required'); + process.exit(1); +} + +const scriptDir = resolve(fileURLToPath(new URL('.', import.meta.url))); +const migrationsDir = resolve(scriptDir, '../sql/v2'); + +const migrationFiles = readdirSync(migrationsDir) + .filter((file) => file.endsWith('.sql')) + .sort(); + +const pool = new Pool({ + connectionString: databaseUrl, + max: Number.parseInt(process.env.DB_POOL_MAX || '5', 10), +}); + +async function ensureMigrationTable(client) { + await client.query(` + CREATE TABLE IF NOT EXISTS schema_migrations ( + version TEXT PRIMARY KEY, + applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW() + ); + `); +} + +try { + const client = await pool.connect(); + try { + await client.query('BEGIN'); + await ensureMigrationTable(client); + + for (const file of migrationFiles) { + const alreadyApplied = await client.query( + 'SELECT 1 FROM schema_migrations WHERE version = $1', + [file] + ); + if (alreadyApplied.rowCount > 0) { + continue; + } + + const sql = readFileSync(resolve(migrationsDir, file), 'utf8'); + await client.query(sql); + await client.query( + 'INSERT INTO schema_migrations (version) VALUES ($1)', + [file] + ); + // eslint-disable-next-line no-console + console.log(`Applied migration ${file}`); + } + + await client.query('COMMIT'); + } catch (error) { + await client.query('ROLLBACK'); + throw error; + } finally { + client.release(); + } +} finally { + await pool.end(); +} diff --git a/backend/command-api/scripts/seed-v2-demo-data.mjs b/backend/command-api/scripts/seed-v2-demo-data.mjs new file mode 100644 index 00000000..c14ce89b --- /dev/null +++ b/backend/command-api/scripts/seed-v2-demo-data.mjs @@ -0,0 +1,600 @@ +import { Pool } from 'pg'; +import { resolveDatabasePoolConfig } from '../src/services/db.js'; +import { V2DemoFixture as fixture } from './v2-demo-fixture.mjs'; + +const poolConfig = resolveDatabasePoolConfig(); + +if (!poolConfig) { + // eslint-disable-next-line no-console + console.error('Database connection settings are required'); + process.exit(1); +} + +const pool = new Pool(poolConfig); + +function hoursFromNow(hours) { + return new Date(Date.now() + (hours * 60 * 60 * 1000)).toISOString(); +} + +async function upsertUser(client, user) { + await client.query( + ` + INSERT INTO users (id, email, display_name, status, metadata) + VALUES ($1, $2, $3, 'ACTIVE', '{}'::jsonb) + ON CONFLICT (id) DO UPDATE + SET email = EXCLUDED.email, + display_name = EXCLUDED.display_name, + status = 'ACTIVE', + updated_at = NOW() + `, + [user.id, user.email || null, user.displayName || null] + ); +} + +async function main() { + const client = await pool.connect(); + try { + await client.query('BEGIN'); + + await client.query('DELETE FROM tenants WHERE id = $1', [fixture.tenant.id]); + + const openStartsAt = hoursFromNow(4); + const openEndsAt = hoursFromNow(12); + const completedStartsAt = hoursFromNow(-28); + const completedEndsAt = hoursFromNow(-20); + const checkedInAt = hoursFromNow(-27.5); + const checkedOutAt = hoursFromNow(-20.25); + const invoiceDueAt = hoursFromNow(72); + + await upsertUser(client, fixture.users.businessOwner); + await upsertUser(client, fixture.users.operationsManager); + await upsertUser(client, fixture.users.vendorManager); + + await client.query( + ` + INSERT INTO tenants (id, slug, name, status, metadata) + VALUES ($1, $2, $3, 'ACTIVE', $4::jsonb) + `, + [fixture.tenant.id, fixture.tenant.slug, fixture.tenant.name, JSON.stringify({ seededBy: 'seed-v2-demo-data' })] + ); + + await client.query( + ` + INSERT INTO tenant_memberships (tenant_id, user_id, membership_status, base_role, metadata) + VALUES + ($1, $2, 'ACTIVE', 'admin', '{"persona":"business_owner"}'::jsonb), + ($1, $3, 'ACTIVE', 'manager', '{"persona":"ops_manager"}'::jsonb), + ($1, $4, 'ACTIVE', 'manager', '{"persona":"vendor_manager"}'::jsonb) + `, + [ + fixture.tenant.id, + fixture.users.businessOwner.id, + fixture.users.operationsManager.id, + fixture.users.vendorManager.id, + ] + ); + + await client.query( + ` + INSERT INTO businesses ( + id, tenant_id, slug, business_name, status, contact_name, contact_email, contact_phone, metadata + ) + VALUES ($1, $2, $3, $4, 'ACTIVE', $5, $6, $7, $8::jsonb) + `, + [ + fixture.business.id, + fixture.tenant.id, + fixture.business.slug, + fixture.business.name, + 'Legendary Client Manager', + fixture.users.businessOwner.email, + '+15550001001', + JSON.stringify({ segment: 'buyer', seeded: true }), + ] + ); + + await client.query( + ` + INSERT INTO business_memberships ( + tenant_id, business_id, user_id, membership_status, business_role, metadata + ) + VALUES + ($1, $2, $3, 'ACTIVE', 'owner', '{"persona":"client_owner"}'::jsonb), + ($1, $2, $4, 'ACTIVE', 'manager', '{"persona":"client_ops"}'::jsonb) + `, + [fixture.tenant.id, fixture.business.id, fixture.users.businessOwner.id, fixture.users.operationsManager.id] + ); + + await client.query( + ` + INSERT INTO vendors ( + id, tenant_id, slug, company_name, status, contact_name, contact_email, contact_phone, metadata + ) + VALUES ($1, $2, $3, $4, 'ACTIVE', $5, $6, $7, $8::jsonb) + `, + [ + fixture.vendor.id, + fixture.tenant.id, + fixture.vendor.slug, + fixture.vendor.name, + 'Vendor Manager', + fixture.users.vendorManager.email, + '+15550001002', + JSON.stringify({ kind: 'internal_pool', seeded: true }), + ] + ); + + await client.query( + ` + INSERT INTO vendor_memberships ( + tenant_id, vendor_id, user_id, membership_status, vendor_role, metadata + ) + VALUES ($1, $2, $3, 'ACTIVE', 'owner', '{"persona":"vendor_owner"}'::jsonb) + `, + [fixture.tenant.id, fixture.vendor.id, fixture.users.vendorManager.id] + ); + + await client.query( + ` + INSERT INTO roles_catalog (id, tenant_id, code, name, status, metadata) + VALUES + ($1, $3, $4, $5, 'ACTIVE', '{}'::jsonb), + ($2, $3, $6, $7, 'ACTIVE', '{}'::jsonb) + `, + [ + fixture.roles.barista.id, + fixture.roles.captain.id, + fixture.tenant.id, + fixture.roles.barista.code, + fixture.roles.barista.name, + fixture.roles.captain.code, + fixture.roles.captain.name, + ] + ); + + await client.query( + ` + INSERT INTO staffs ( + id, tenant_id, user_id, full_name, email, phone, status, primary_role, onboarding_status, + average_rating, rating_count, metadata + ) + VALUES ($1, $2, NULL, $3, $4, $5, 'ACTIVE', $6, 'COMPLETED', 4.50, 1, $7::jsonb) + `, + [ + fixture.staff.ana.id, + fixture.tenant.id, + fixture.staff.ana.fullName, + fixture.staff.ana.email, + fixture.staff.ana.phone, + fixture.staff.ana.primaryRole, + JSON.stringify({ favoriteCandidate: true, seeded: true }), + ] + ); + + await client.query( + ` + INSERT INTO staff_roles (staff_id, role_id, is_primary) + VALUES ($1, $2, TRUE) + `, + [fixture.staff.ana.id, fixture.roles.barista.id] + ); + + await client.query( + ` + INSERT INTO workforce (id, tenant_id, vendor_id, staff_id, workforce_number, employment_type, status, metadata) + VALUES ($1, $2, $3, $4, $5, 'TEMP', 'ACTIVE', $6::jsonb) + `, + [ + fixture.workforce.ana.id, + fixture.tenant.id, + fixture.vendor.id, + fixture.staff.ana.id, + fixture.workforce.ana.workforceNumber, + JSON.stringify({ source: 'seed-v2-demo' }), + ] + ); + + await client.query( + ` + INSERT INTO clock_points ( + id, tenant_id, business_id, label, address, latitude, longitude, geofence_radius_meters, nfc_tag_uid, status, metadata + ) + VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, 'ACTIVE', '{}'::jsonb) + `, + [ + fixture.clockPoint.id, + fixture.tenant.id, + fixture.business.id, + fixture.clockPoint.label, + fixture.clockPoint.address, + fixture.clockPoint.latitude, + fixture.clockPoint.longitude, + fixture.clockPoint.geofenceRadiusMeters, + fixture.clockPoint.nfcTagUid, + ] + ); + + await client.query( + ` + INSERT INTO orders ( + id, tenant_id, business_id, vendor_id, order_number, title, description, status, service_type, + starts_at, ends_at, location_name, location_address, latitude, longitude, notes, created_by_user_id, metadata + ) + VALUES + ($1, $3, $4, $5, $6, $7, 'Open order for live v2 commands', 'OPEN', 'EVENT', $8, $9, 'Google Cafe', $10, $11, $12, 'Use this order for live smoke and frontend reads', $13, '{"slice":"open"}'::jsonb), + ($2, $3, $4, $5, $14, $15, 'Completed order for favorites, reviews, invoices, and attendance history', 'COMPLETED', 'CATERING', $16, $17, 'Google Catering', $10, $11, $12, 'Completed historical example', $13, '{"slice":"completed"}'::jsonb) + `, + [ + fixture.orders.open.id, + fixture.orders.completed.id, + fixture.tenant.id, + fixture.business.id, + fixture.vendor.id, + fixture.orders.open.number, + fixture.orders.open.title, + openStartsAt, + openEndsAt, + fixture.clockPoint.address, + fixture.clockPoint.latitude, + fixture.clockPoint.longitude, + fixture.users.businessOwner.id, + fixture.orders.completed.number, + fixture.orders.completed.title, + completedStartsAt, + completedEndsAt, + ] + ); + + await client.query( + ` + INSERT INTO shifts ( + id, tenant_id, order_id, business_id, vendor_id, clock_point_id, shift_code, title, status, starts_at, ends_at, timezone, + location_name, location_address, latitude, longitude, geofence_radius_meters, required_workers, assigned_workers, notes, metadata + ) + VALUES + ($1, $3, $5, $7, $9, $11, $13, $15, 'OPEN', $17, $18, 'America/Los_Angeles', 'Google Cafe', $19, $21, $22, $23, 1, 0, 'Open staffing need', '{"slice":"open"}'::jsonb), + ($2, $4, $6, $8, $10, $12, $14, $16, 'COMPLETED', $20, $24, 'America/Los_Angeles', 'Google Catering', $19, $21, $22, $23, 1, 1, 'Completed staffed shift', '{"slice":"completed"}'::jsonb) + `, + [ + fixture.shifts.open.id, + fixture.shifts.completed.id, + fixture.tenant.id, + fixture.tenant.id, + fixture.orders.open.id, + fixture.orders.completed.id, + fixture.business.id, + fixture.business.id, + fixture.vendor.id, + fixture.vendor.id, + fixture.clockPoint.id, + fixture.clockPoint.id, + fixture.shifts.open.code, + fixture.shifts.completed.code, + fixture.shifts.open.title, + fixture.shifts.completed.title, + openStartsAt, + openEndsAt, + fixture.clockPoint.address, + completedStartsAt, + fixture.clockPoint.latitude, + fixture.clockPoint.longitude, + fixture.clockPoint.geofenceRadiusMeters, + completedEndsAt, + ] + ); + + await client.query( + ` + INSERT INTO shift_roles ( + id, shift_id, role_id, role_code, role_name, workers_needed, assigned_count, pay_rate_cents, bill_rate_cents, metadata + ) + VALUES + ($1, $2, $3, $4, $5, 1, 0, 2200, 3500, '{"slice":"open"}'::jsonb), + ($6, $7, $3, $4, $5, 1, 1, 2200, 3500, '{"slice":"completed"}'::jsonb) + `, + [ + fixture.shiftRoles.openBarista.id, + fixture.shifts.open.id, + fixture.roles.barista.id, + fixture.roles.barista.code, + fixture.roles.barista.name, + fixture.shiftRoles.completedBarista.id, + fixture.shifts.completed.id, + ] + ); + + await client.query( + ` + INSERT INTO applications ( + id, tenant_id, shift_id, shift_role_id, staff_id, status, origin, applied_at, metadata + ) + VALUES ($1, $2, $3, $4, $5, 'PENDING', 'STAFF', NOW(), '{"slice":"open"}'::jsonb) + `, + [ + fixture.applications.openAna.id, + fixture.tenant.id, + fixture.shifts.open.id, + fixture.shiftRoles.openBarista.id, + fixture.staff.ana.id, + ] + ); + + await client.query( + ` + INSERT INTO assignments ( + id, tenant_id, business_id, vendor_id, shift_id, shift_role_id, workforce_id, staff_id, status, + assigned_at, accepted_at, checked_in_at, checked_out_at, metadata + ) + VALUES ($1, $2, $3, $4, $5, $6, $7, $8, 'COMPLETED', $9, $10, $11, $12, '{"slice":"completed"}'::jsonb) + `, + [ + fixture.assignments.completedAna.id, + fixture.tenant.id, + fixture.business.id, + fixture.vendor.id, + fixture.shifts.completed.id, + fixture.shiftRoles.completedBarista.id, + fixture.workforce.ana.id, + fixture.staff.ana.id, + completedStartsAt, + completedStartsAt, + checkedInAt, + checkedOutAt, + ] + ); + + await client.query( + ` + INSERT INTO attendance_events ( + tenant_id, assignment_id, shift_id, staff_id, clock_point_id, event_type, source_type, source_reference, + nfc_tag_uid, device_id, latitude, longitude, accuracy_meters, distance_to_clock_point_meters, within_geofence, + validation_status, validation_reason, captured_at, raw_payload + ) + VALUES + ($1, $2, $3, $4, $5, 'CLOCK_IN', 'NFC', 'seed', $6, 'seed-device', $7, $8, 5, 0, TRUE, 'ACCEPTED', NULL, $9, '{"seeded":true}'::jsonb), + ($1, $2, $3, $4, $5, 'CLOCK_OUT', 'NFC', 'seed', $6, 'seed-device', $7, $8, 5, 0, TRUE, 'ACCEPTED', NULL, $10, '{"seeded":true}'::jsonb) + `, + [ + fixture.tenant.id, + fixture.assignments.completedAna.id, + fixture.shifts.completed.id, + fixture.staff.ana.id, + fixture.clockPoint.id, + fixture.clockPoint.nfcTagUid, + fixture.clockPoint.latitude, + fixture.clockPoint.longitude, + checkedInAt, + checkedOutAt, + ] + ); + + const attendanceEvents = await client.query( + ` + SELECT id, event_type + FROM attendance_events + WHERE assignment_id = $1 + ORDER BY captured_at ASC + `, + [fixture.assignments.completedAna.id] + ); + + await client.query( + ` + INSERT INTO attendance_sessions ( + id, tenant_id, assignment_id, staff_id, clock_in_event_id, clock_out_event_id, status, + check_in_at, check_out_at, worked_minutes, metadata + ) + VALUES ($1, $2, $3, $4, $5, $6, 'CLOSED', $7, $8, 435, '{"seeded":true}'::jsonb) + `, + [ + '95f6017c-256c-4eb5-8033-eb942f018001', + fixture.tenant.id, + fixture.assignments.completedAna.id, + fixture.staff.ana.id, + attendanceEvents.rows.find((row) => row.event_type === 'CLOCK_IN')?.id, + attendanceEvents.rows.find((row) => row.event_type === 'CLOCK_OUT')?.id, + checkedInAt, + checkedOutAt, + ] + ); + + await client.query( + ` + INSERT INTO timesheets ( + id, tenant_id, assignment_id, staff_id, status, regular_minutes, overtime_minutes, break_minutes, gross_pay_cents, metadata + ) + VALUES ($1, $2, $3, $4, 'APPROVED', 420, 15, 30, 15950, '{"seeded":true}'::jsonb) + `, + [fixture.timesheets.completedAna.id, fixture.tenant.id, fixture.assignments.completedAna.id, fixture.staff.ana.id] + ); + + await client.query( + ` + INSERT INTO documents (id, tenant_id, document_type, name, required_for_role_code, metadata) + VALUES ($1, $2, 'CERTIFICATION', $3, $4, '{"seeded":true}'::jsonb) + `, + [fixture.documents.foodSafety.id, fixture.tenant.id, fixture.documents.foodSafety.name, fixture.roles.barista.code] + ); + + await client.query( + ` + INSERT INTO staff_documents (id, tenant_id, staff_id, document_id, file_uri, status, expires_at, metadata) + VALUES ($1, $2, $3, $4, $5, 'VERIFIED', $6, '{"seeded":true}'::jsonb) + `, + [ + fixture.staffDocuments.foodSafety.id, + fixture.tenant.id, + fixture.staff.ana.id, + fixture.documents.foodSafety.id, + `gs://krow-workforce-dev-v2-private/uploads/${fixture.staff.ana.id}/food-handler-card.pdf`, + hoursFromNow(24 * 180), + ] + ); + + await client.query( + ` + INSERT INTO certificates (id, tenant_id, staff_id, certificate_type, certificate_number, issued_at, expires_at, status, metadata) + VALUES ($1, $2, $3, 'FOOD_SAFETY', 'FH-ANA-2026', $4, $5, 'VERIFIED', '{"seeded":true}'::jsonb) + `, + [ + fixture.certificates.foodSafety.id, + fixture.tenant.id, + fixture.staff.ana.id, + hoursFromNow(-24 * 30), + hoursFromNow(24 * 180), + ] + ); + + await client.query( + ` + INSERT INTO verification_jobs ( + tenant_id, staff_id, document_id, type, file_uri, status, idempotency_key, + provider_name, provider_reference, confidence, reasons, extracted, review, metadata + ) + VALUES ( + $1, $2, $3, 'certification', $4, 'APPROVED', 'seed-certification-job', + 'seed', 'seed-certification-provider', 0.980, '["Verified by seed"]'::jsonb, + '{"certificateType":"FOOD_SAFETY"}'::jsonb, '{"decision":"APPROVED"}'::jsonb, '{"seeded":true}'::jsonb + ) + `, + [ + fixture.tenant.id, + fixture.staff.ana.id, + fixture.documents.foodSafety.id, + `gs://krow-workforce-dev-v2-private/uploads/${fixture.staff.ana.id}/food-handler-card.pdf`, + ] + ); + + await client.query( + ` + INSERT INTO accounts ( + id, tenant_id, owner_type, owner_business_id, owner_vendor_id, owner_staff_id, + provider_name, provider_reference, last4, is_primary, metadata + ) + VALUES + ($1, $3, 'BUSINESS', $4, NULL, NULL, 'stripe', 'ba_business_demo', '6789', TRUE, '{"seeded":true}'::jsonb), + ($2, $3, 'STAFF', NULL, NULL, $5, 'stripe', 'ba_staff_demo', '4321', TRUE, '{"seeded":true}'::jsonb) + `, + [ + fixture.accounts.businessPrimary.id, + fixture.accounts.staffPrimary.id, + fixture.tenant.id, + fixture.business.id, + fixture.staff.ana.id, + ] + ); + + await client.query( + ` + INSERT INTO invoices ( + id, tenant_id, order_id, business_id, vendor_id, invoice_number, status, currency_code, + subtotal_cents, tax_cents, total_cents, due_at, metadata + ) + VALUES ($1, $2, $3, $4, $5, $6, 'PENDING_REVIEW', 'USD', 15250, 700, 15950, $7, '{"seeded":true}'::jsonb) + `, + [ + fixture.invoices.completed.id, + fixture.tenant.id, + fixture.orders.completed.id, + fixture.business.id, + fixture.vendor.id, + fixture.invoices.completed.number, + invoiceDueAt, + ] + ); + + await client.query( + ` + INSERT INTO recent_payments ( + id, tenant_id, invoice_id, assignment_id, staff_id, status, amount_cents, process_date, metadata + ) + VALUES ($1, $2, $3, $4, $5, 'PENDING', 15950, NULL, '{"seeded":true}'::jsonb) + `, + [ + fixture.recentPayments.completed.id, + fixture.tenant.id, + fixture.invoices.completed.id, + fixture.assignments.completedAna.id, + fixture.staff.ana.id, + ] + ); + + await client.query( + ` + INSERT INTO staff_favorites (id, tenant_id, business_id, staff_id, created_by_user_id, created_at) + VALUES ($1, $2, $3, $4, $5, NOW()) + `, + [ + fixture.favorites.ana.id, + fixture.tenant.id, + fixture.business.id, + fixture.staff.ana.id, + fixture.users.businessOwner.id, + ] + ); + + await client.query( + ` + INSERT INTO staff_reviews ( + id, tenant_id, business_id, staff_id, assignment_id, reviewer_user_id, rating, review_text, tags, created_at, updated_at + ) + VALUES ($1, $2, $3, $4, $5, $6, 5, 'Reliable, on time, and client friendly.', '["reliable","favorite"]'::jsonb, NOW(), NOW()) + `, + [ + fixture.reviews.anaCompleted.id, + fixture.tenant.id, + fixture.business.id, + fixture.staff.ana.id, + fixture.assignments.completedAna.id, + fixture.users.businessOwner.id, + ] + ); + + await client.query( + ` + INSERT INTO domain_events (tenant_id, aggregate_type, aggregate_id, sequence, event_type, actor_user_id, payload) + VALUES + ($1, 'order', $2, 1, 'ORDER_CREATED', $3, '{"seeded":true}'::jsonb), + ($1, 'assignment', $4, 1, 'STAFF_ASSIGNED', $3, '{"seeded":true}'::jsonb) + `, + [ + fixture.tenant.id, + fixture.orders.completed.id, + fixture.users.businessOwner.id, + fixture.assignments.completedAna.id, + ] + ); + + await client.query('COMMIT'); + + // eslint-disable-next-line no-console + console.log(JSON.stringify({ + tenantId: fixture.tenant.id, + businessId: fixture.business.id, + vendorId: fixture.vendor.id, + staffId: fixture.staff.ana.id, + workforceId: fixture.workforce.ana.id, + openOrderId: fixture.orders.open.id, + openShiftId: fixture.shifts.open.id, + openShiftRoleId: fixture.shiftRoles.openBarista.id, + openApplicationId: fixture.applications.openAna.id, + completedOrderId: fixture.orders.completed.id, + completedAssignmentId: fixture.assignments.completedAna.id, + clockPointId: fixture.clockPoint.id, + nfcTagUid: fixture.clockPoint.nfcTagUid, + businessOwnerUid: fixture.users.businessOwner.id, + }, null, 2)); + } catch (error) { + await client.query('ROLLBACK'); + throw error; + } finally { + client.release(); + await pool.end(); + } +} + +main().catch((error) => { + // eslint-disable-next-line no-console + console.error(error); + process.exit(1); +}); diff --git a/backend/command-api/scripts/v2-demo-fixture.mjs b/backend/command-api/scripts/v2-demo-fixture.mjs new file mode 100644 index 00000000..04cea3e0 --- /dev/null +++ b/backend/command-api/scripts/v2-demo-fixture.mjs @@ -0,0 +1,162 @@ +export const V2DemoFixture = { + tenant: { + id: '6d5fa42c-1f38-49be-8895-8aeb0e731001', + slug: 'legendary-event-staffing', + name: 'Legendary Event Staffing and Entertainment', + }, + users: { + businessOwner: { + id: process.env.V2_DEMO_OWNER_UID || 'dvpWnaBjT6UksS5lo04hfMTyq1q1', + email: process.env.V2_DEMO_OWNER_EMAIL || 'legendary@krowd.com', + displayName: 'Legendary Demo Owner', + }, + operationsManager: { + id: 'demo-ops-manager', + email: 'ops+v2@krowd.com', + displayName: 'Wil Ops Lead', + }, + vendorManager: { + id: 'demo-vendor-manager', + email: 'vendor+v2@krowd.com', + displayName: 'Vendor Manager', + }, + }, + business: { + id: '14f4fcfb-f21f-4ba9-9328-90f794a56001', + slug: 'google-mv-cafes', + name: 'Google Mountain View Cafes', + }, + vendor: { + id: '80f8c8d3-9da8-4892-908f-4d4982af7001', + slug: 'legendary-pool-a', + name: 'Legendary Staffing Pool A', + }, + roles: { + barista: { + id: '67c5010e-85f0-4f6b-99b7-167c9afdf001', + code: 'BARISTA', + name: 'Barista', + }, + captain: { + id: '67c5010e-85f0-4f6b-99b7-167c9afdf002', + code: 'CAPTAIN', + name: 'Captain', + }, + }, + staff: { + ana: { + id: '4b7dff1a-1856-4d59-b450-5a6736461001', + fullName: 'Ana Barista', + email: 'ana.barista+v2@krowd.com', + phone: '+15557654321', + primaryRole: 'BARISTA', + }, + }, + workforce: { + ana: { + id: '4cc1d34a-87c3-4426-8ee0-a24c8bcfa001', + workforceNumber: 'WF-V2-ANA-001', + }, + }, + clockPoint: { + id: 'efb80ccf-3361-49c8-bc74-ff8cd4d2e001', + label: 'Google MV Cafe Clock Point', + address: '1600 Amphitheatre Pkwy, Mountain View, CA', + latitude: 37.4221, + longitude: -122.0841, + geofenceRadiusMeters: 120, + nfcTagUid: 'NFC-DEMO-ANA-001', + }, + orders: { + open: { + id: 'b6132d7a-45c3-4879-b349-46b2fd518001', + number: 'ORD-V2-OPEN-1001', + title: 'Morning cafe staffing', + }, + completed: { + id: 'b6132d7a-45c3-4879-b349-46b2fd518002', + number: 'ORD-V2-COMP-1002', + title: 'Completed catering shift', + }, + }, + shifts: { + open: { + id: '6e7dadad-99e4-45bb-b0da-7bb617954001', + code: 'SHIFT-V2-OPEN-1', + title: 'Open breakfast shift', + }, + completed: { + id: '6e7dadad-99e4-45bb-b0da-7bb617954002', + code: 'SHIFT-V2-COMP-1', + title: 'Completed catering shift', + }, + }, + shiftRoles: { + openBarista: { + id: '4dd35b2b-4aaf-4c28-a91f-7bda05e2b001', + }, + completedBarista: { + id: '4dd35b2b-4aaf-4c28-a91f-7bda05e2b002', + }, + }, + applications: { + openAna: { + id: 'd70d6441-6d0c-4fdb-9a29-c9d9e0c34001', + }, + }, + assignments: { + completedAna: { + id: 'f1d3f738-a132-4863-b222-4f9cb25aa001', + }, + }, + timesheets: { + completedAna: { + id: '41ea4057-0c55-4907-b525-07315b2b6001', + }, + }, + invoices: { + completed: { + id: '1455e15b-77f9-4c66-b2a8-dce35f7ac001', + number: 'INV-V2-2001', + }, + }, + recentPayments: { + completed: { + id: 'be6f736b-e945-4676-a73d-2912c7575001', + }, + }, + favorites: { + ana: { + id: 'ba5cb8fa-0be9-4ef4-a9fb-e60a8a48e001', + }, + }, + reviews: { + anaCompleted: { + id: '9b6bc737-fd69-4855-b425-6f0c2c4fd001', + }, + }, + documents: { + foodSafety: { + id: 'e6fd0183-34d9-4c23-9a9a-bf98da995001', + name: 'Food Handler Card', + }, + }, + staffDocuments: { + foodSafety: { + id: '4b157236-a4b0-4c44-b199-7d4ea1f95001', + }, + }, + certificates: { + foodSafety: { + id: 'df6452dc-4ec7-4d54-876d-26bf8ce5b001', + }, + }, + accounts: { + businessPrimary: { + id: '5d98e0ba-8e89-4ffb-aafd-df6bbe2fe001', + }, + staffPrimary: { + id: '5d98e0ba-8e89-4ffb-aafd-df6bbe2fe002', + }, + }, +}; diff --git a/backend/command-api/sql/v2/001_v2_domain_foundation.sql b/backend/command-api/sql/v2/001_v2_domain_foundation.sql new file mode 100644 index 00000000..5d871caf --- /dev/null +++ b/backend/command-api/sql/v2/001_v2_domain_foundation.sql @@ -0,0 +1,639 @@ +CREATE EXTENSION IF NOT EXISTS pgcrypto; + +CREATE TABLE IF NOT EXISTS tenants ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + slug TEXT NOT NULL UNIQUE, + name TEXT NOT NULL, + status TEXT NOT NULL DEFAULT 'ACTIVE' CHECK (status IN ('ACTIVE', 'INACTIVE')), + metadata JSONB NOT NULL DEFAULT '{}'::jsonb, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE TABLE IF NOT EXISTS users ( + id TEXT PRIMARY KEY, + email TEXT, + display_name TEXT, + phone TEXT, + status TEXT NOT NULL DEFAULT 'ACTIVE' CHECK (status IN ('ACTIVE', 'INVITED', 'DISABLED')), + metadata JSONB NOT NULL DEFAULT '{}'::jsonb, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_users_email_unique + ON users (LOWER(email)) + WHERE email IS NOT NULL; + +CREATE TABLE IF NOT EXISTS tenant_memberships ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id) ON DELETE CASCADE, + user_id TEXT REFERENCES users(id) ON DELETE SET NULL, + invited_email TEXT, + membership_status TEXT NOT NULL DEFAULT 'ACTIVE' + CHECK (membership_status IN ('INVITED', 'ACTIVE', 'SUSPENDED', 'REMOVED')), + base_role TEXT NOT NULL DEFAULT 'member' + CHECK (base_role IN ('admin', 'manager', 'member', 'viewer')), + metadata JSONB NOT NULL DEFAULT '{}'::jsonb, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + CONSTRAINT chk_tenant_membership_identity + CHECK (user_id IS NOT NULL OR invited_email IS NOT NULL) +); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_tenant_memberships_tenant_user + ON tenant_memberships (tenant_id, user_id) + WHERE user_id IS NOT NULL; + +CREATE UNIQUE INDEX IF NOT EXISTS idx_tenant_memberships_tenant_invited_email + ON tenant_memberships (tenant_id, LOWER(invited_email)) + WHERE invited_email IS NOT NULL; + +CREATE TABLE IF NOT EXISTS businesses ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id) ON DELETE CASCADE, + slug TEXT NOT NULL, + business_name TEXT NOT NULL, + status TEXT NOT NULL DEFAULT 'ACTIVE' + CHECK (status IN ('ACTIVE', 'INACTIVE', 'ARCHIVED')), + contact_name TEXT, + contact_email TEXT, + contact_phone TEXT, + metadata JSONB NOT NULL DEFAULT '{}'::jsonb, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_businesses_tenant_slug + ON businesses (tenant_id, slug); + +CREATE TABLE IF NOT EXISTS business_memberships ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id) ON DELETE CASCADE, + business_id UUID NOT NULL REFERENCES businesses(id) ON DELETE CASCADE, + user_id TEXT REFERENCES users(id) ON DELETE SET NULL, + invited_email TEXT, + membership_status TEXT NOT NULL DEFAULT 'ACTIVE' + CHECK (membership_status IN ('INVITED', 'ACTIVE', 'SUSPENDED', 'REMOVED')), + business_role TEXT NOT NULL DEFAULT 'member' + CHECK (business_role IN ('owner', 'manager', 'member', 'viewer')), + metadata JSONB NOT NULL DEFAULT '{}'::jsonb, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + CONSTRAINT chk_business_membership_identity + CHECK (user_id IS NOT NULL OR invited_email IS NOT NULL) +); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_business_memberships_business_user + ON business_memberships (business_id, user_id) + WHERE user_id IS NOT NULL; + +CREATE UNIQUE INDEX IF NOT EXISTS idx_business_memberships_business_invited_email + ON business_memberships (business_id, LOWER(invited_email)) + WHERE invited_email IS NOT NULL; + +CREATE TABLE IF NOT EXISTS vendors ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id) ON DELETE CASCADE, + slug TEXT NOT NULL, + company_name TEXT NOT NULL, + status TEXT NOT NULL DEFAULT 'ACTIVE' + CHECK (status IN ('ACTIVE', 'INACTIVE', 'ARCHIVED')), + contact_name TEXT, + contact_email TEXT, + contact_phone TEXT, + metadata JSONB NOT NULL DEFAULT '{}'::jsonb, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_vendors_tenant_slug + ON vendors (tenant_id, slug); + +CREATE TABLE IF NOT EXISTS vendor_memberships ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id) ON DELETE CASCADE, + vendor_id UUID NOT NULL REFERENCES vendors(id) ON DELETE CASCADE, + user_id TEXT REFERENCES users(id) ON DELETE SET NULL, + invited_email TEXT, + membership_status TEXT NOT NULL DEFAULT 'ACTIVE' + CHECK (membership_status IN ('INVITED', 'ACTIVE', 'SUSPENDED', 'REMOVED')), + vendor_role TEXT NOT NULL DEFAULT 'member' + CHECK (vendor_role IN ('owner', 'manager', 'member', 'viewer')), + metadata JSONB NOT NULL DEFAULT '{}'::jsonb, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + CONSTRAINT chk_vendor_membership_identity + CHECK (user_id IS NOT NULL OR invited_email IS NOT NULL) +); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_vendor_memberships_vendor_user + ON vendor_memberships (vendor_id, user_id) + WHERE user_id IS NOT NULL; + +CREATE UNIQUE INDEX IF NOT EXISTS idx_vendor_memberships_vendor_invited_email + ON vendor_memberships (vendor_id, LOWER(invited_email)) + WHERE invited_email IS NOT NULL; + +CREATE TABLE IF NOT EXISTS staffs ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id) ON DELETE CASCADE, + user_id TEXT REFERENCES users(id) ON DELETE SET NULL, + full_name TEXT NOT NULL, + email TEXT, + phone TEXT, + status TEXT NOT NULL DEFAULT 'ACTIVE' + CHECK (status IN ('ACTIVE', 'INVITED', 'INACTIVE', 'BLOCKED')), + primary_role TEXT, + onboarding_status TEXT NOT NULL DEFAULT 'PENDING' + CHECK (onboarding_status IN ('PENDING', 'IN_PROGRESS', 'COMPLETED')), + average_rating NUMERIC(3, 2) NOT NULL DEFAULT 0 CHECK (average_rating >= 0 AND average_rating <= 5), + rating_count INTEGER NOT NULL DEFAULT 0 CHECK (rating_count >= 0), + metadata JSONB NOT NULL DEFAULT '{}'::jsonb, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_staffs_tenant_user + ON staffs (tenant_id, user_id) + WHERE user_id IS NOT NULL; + +CREATE TABLE IF NOT EXISTS workforce ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id) ON DELETE CASCADE, + vendor_id UUID NOT NULL REFERENCES vendors(id) ON DELETE CASCADE, + staff_id UUID NOT NULL REFERENCES staffs(id) ON DELETE CASCADE, + workforce_number TEXT NOT NULL, + employment_type TEXT NOT NULL + CHECK (employment_type IN ('W2', 'W1099', 'TEMP', 'CONTRACT')), + status TEXT NOT NULL DEFAULT 'ACTIVE' + CHECK (status IN ('ACTIVE', 'INACTIVE', 'SUSPENDED')), + metadata JSONB NOT NULL DEFAULT '{}'::jsonb, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_workforce_vendor_staff + ON workforce (vendor_id, staff_id); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_workforce_number_tenant + ON workforce (tenant_id, workforce_number); + +CREATE TABLE IF NOT EXISTS roles_catalog ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id) ON DELETE CASCADE, + code TEXT NOT NULL, + name TEXT NOT NULL, + status TEXT NOT NULL DEFAULT 'ACTIVE' + CHECK (status IN ('ACTIVE', 'INACTIVE')), + metadata JSONB NOT NULL DEFAULT '{}'::jsonb, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_roles_catalog_tenant_code + ON roles_catalog (tenant_id, code); + +CREATE TABLE IF NOT EXISTS staff_roles ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + staff_id UUID NOT NULL REFERENCES staffs(id) ON DELETE CASCADE, + role_id UUID NOT NULL REFERENCES roles_catalog(id) ON DELETE CASCADE, + is_primary BOOLEAN NOT NULL DEFAULT FALSE, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_staff_roles_staff_role + ON staff_roles (staff_id, role_id); + +CREATE TABLE IF NOT EXISTS clock_points ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id) ON DELETE CASCADE, + business_id UUID REFERENCES businesses(id) ON DELETE SET NULL, + label TEXT NOT NULL, + address TEXT, + latitude NUMERIC(9, 6), + longitude NUMERIC(9, 6), + geofence_radius_meters INTEGER NOT NULL DEFAULT 100 CHECK (geofence_radius_meters > 0), + nfc_tag_uid TEXT, + status TEXT NOT NULL DEFAULT 'ACTIVE' + CHECK (status IN ('ACTIVE', 'INACTIVE')), + metadata JSONB NOT NULL DEFAULT '{}'::jsonb, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_clock_points_tenant_nfc_tag + ON clock_points (tenant_id, nfc_tag_uid) + WHERE nfc_tag_uid IS NOT NULL; + +CREATE TABLE IF NOT EXISTS orders ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id) ON DELETE CASCADE, + business_id UUID NOT NULL REFERENCES businesses(id) ON DELETE RESTRICT, + vendor_id UUID REFERENCES vendors(id) ON DELETE SET NULL, + order_number TEXT NOT NULL, + title TEXT NOT NULL, + description TEXT, + status TEXT NOT NULL DEFAULT 'DRAFT' + CHECK (status IN ('DRAFT', 'OPEN', 'FILLED', 'ACTIVE', 'COMPLETED', 'CANCELLED')), + service_type TEXT NOT NULL DEFAULT 'EVENT' + CHECK (service_type IN ('EVENT', 'CATERING', 'HOTEL', 'RESTAURANT', 'OTHER')), + starts_at TIMESTAMPTZ, + ends_at TIMESTAMPTZ, + location_name TEXT, + location_address TEXT, + latitude NUMERIC(9, 6), + longitude NUMERIC(9, 6), + notes TEXT, + created_by_user_id TEXT REFERENCES users(id) ON DELETE SET NULL, + metadata JSONB NOT NULL DEFAULT '{}'::jsonb, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + CONSTRAINT chk_orders_time_window CHECK (starts_at IS NULL OR ends_at IS NULL OR starts_at < ends_at) +); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_orders_tenant_order_number + ON orders (tenant_id, order_number); + +CREATE INDEX IF NOT EXISTS idx_orders_tenant_business_status + ON orders (tenant_id, business_id, status, created_at DESC); + +CREATE TABLE IF NOT EXISTS shifts ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id) ON DELETE CASCADE, + order_id UUID NOT NULL REFERENCES orders(id) ON DELETE CASCADE, + business_id UUID NOT NULL REFERENCES businesses(id) ON DELETE RESTRICT, + vendor_id UUID REFERENCES vendors(id) ON DELETE SET NULL, + clock_point_id UUID REFERENCES clock_points(id) ON DELETE SET NULL, + shift_code TEXT NOT NULL, + title TEXT NOT NULL, + status TEXT NOT NULL DEFAULT 'OPEN' + CHECK (status IN ('DRAFT', 'OPEN', 'PENDING_CONFIRMATION', 'ASSIGNED', 'ACTIVE', 'COMPLETED', 'CANCELLED')), + starts_at TIMESTAMPTZ NOT NULL, + ends_at TIMESTAMPTZ NOT NULL, + timezone TEXT NOT NULL DEFAULT 'UTC', + location_name TEXT, + location_address TEXT, + latitude NUMERIC(9, 6), + longitude NUMERIC(9, 6), + geofence_radius_meters INTEGER CHECK (geofence_radius_meters IS NULL OR geofence_radius_meters > 0), + required_workers INTEGER NOT NULL DEFAULT 1 CHECK (required_workers > 0), + assigned_workers INTEGER NOT NULL DEFAULT 0 CHECK (assigned_workers >= 0), + notes TEXT, + metadata JSONB NOT NULL DEFAULT '{}'::jsonb, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + CONSTRAINT chk_shifts_time_window CHECK (starts_at < ends_at), + CONSTRAINT chk_shifts_assigned_workers CHECK (assigned_workers <= required_workers) +); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_shifts_order_shift_code + ON shifts (order_id, shift_code); + +CREATE INDEX IF NOT EXISTS idx_shifts_tenant_time + ON shifts (tenant_id, starts_at, ends_at); + +CREATE TABLE IF NOT EXISTS shift_roles ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + shift_id UUID NOT NULL REFERENCES shifts(id) ON DELETE CASCADE, + role_id UUID REFERENCES roles_catalog(id) ON DELETE SET NULL, + role_code TEXT NOT NULL, + role_name TEXT NOT NULL, + workers_needed INTEGER NOT NULL CHECK (workers_needed > 0), + assigned_count INTEGER NOT NULL DEFAULT 0 CHECK (assigned_count >= 0), + pay_rate_cents INTEGER NOT NULL DEFAULT 0 CHECK (pay_rate_cents >= 0), + bill_rate_cents INTEGER NOT NULL DEFAULT 0 CHECK (bill_rate_cents >= 0), + metadata JSONB NOT NULL DEFAULT '{}'::jsonb, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + CONSTRAINT chk_shift_roles_assigned_count CHECK (assigned_count <= workers_needed) +); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_shift_roles_shift_role_code + ON shift_roles (shift_id, role_code); + +CREATE TABLE IF NOT EXISTS applications ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id) ON DELETE CASCADE, + shift_id UUID NOT NULL REFERENCES shifts(id) ON DELETE CASCADE, + shift_role_id UUID NOT NULL REFERENCES shift_roles(id) ON DELETE CASCADE, + staff_id UUID NOT NULL REFERENCES staffs(id) ON DELETE CASCADE, + status TEXT NOT NULL DEFAULT 'PENDING' + CHECK (status IN ('PENDING', 'CONFIRMED', 'CHECKED_IN', 'LATE', 'NO_SHOW', 'COMPLETED', 'REJECTED', 'CANCELLED')), + origin TEXT NOT NULL DEFAULT 'STAFF' + CHECK (origin IN ('STAFF', 'BUSINESS', 'VENDOR', 'SYSTEM')), + applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + metadata JSONB NOT NULL DEFAULT '{}'::jsonb, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_applications_shift_role_staff + ON applications (shift_role_id, staff_id); + +CREATE INDEX IF NOT EXISTS idx_applications_staff_status + ON applications (staff_id, status, applied_at DESC); + +CREATE TABLE IF NOT EXISTS assignments ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id) ON DELETE CASCADE, + business_id UUID NOT NULL REFERENCES businesses(id) ON DELETE RESTRICT, + vendor_id UUID REFERENCES vendors(id) ON DELETE SET NULL, + shift_id UUID NOT NULL REFERENCES shifts(id) ON DELETE CASCADE, + shift_role_id UUID NOT NULL REFERENCES shift_roles(id) ON DELETE CASCADE, + workforce_id UUID NOT NULL REFERENCES workforce(id) ON DELETE RESTRICT, + staff_id UUID NOT NULL REFERENCES staffs(id) ON DELETE RESTRICT, + application_id UUID REFERENCES applications(id) ON DELETE SET NULL, + status TEXT NOT NULL DEFAULT 'ASSIGNED' + CHECK (status IN ('ASSIGNED', 'ACCEPTED', 'CHECKED_IN', 'CHECKED_OUT', 'COMPLETED', 'CANCELLED', 'NO_SHOW')), + assigned_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + accepted_at TIMESTAMPTZ, + checked_in_at TIMESTAMPTZ, + checked_out_at TIMESTAMPTZ, + metadata JSONB NOT NULL DEFAULT '{}'::jsonb, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_assignments_shift_role_workforce + ON assignments (shift_role_id, workforce_id); + +CREATE INDEX IF NOT EXISTS idx_assignments_staff_status + ON assignments (staff_id, status, assigned_at DESC); + +CREATE TABLE IF NOT EXISTS attendance_events ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id) ON DELETE CASCADE, + assignment_id UUID NOT NULL REFERENCES assignments(id) ON DELETE CASCADE, + shift_id UUID NOT NULL REFERENCES shifts(id) ON DELETE CASCADE, + staff_id UUID NOT NULL REFERENCES staffs(id) ON DELETE RESTRICT, + clock_point_id UUID REFERENCES clock_points(id) ON DELETE SET NULL, + event_type TEXT NOT NULL + CHECK (event_type IN ('CLOCK_IN', 'CLOCK_OUT', 'MANUAL_ADJUSTMENT')), + source_type TEXT NOT NULL + CHECK (source_type IN ('NFC', 'GEO', 'QR', 'MANUAL', 'SYSTEM')), + source_reference TEXT, + nfc_tag_uid TEXT, + device_id TEXT, + latitude NUMERIC(9, 6), + longitude NUMERIC(9, 6), + accuracy_meters INTEGER CHECK (accuracy_meters IS NULL OR accuracy_meters >= 0), + distance_to_clock_point_meters INTEGER CHECK (distance_to_clock_point_meters IS NULL OR distance_to_clock_point_meters >= 0), + within_geofence BOOLEAN, + validation_status TEXT NOT NULL DEFAULT 'ACCEPTED' + CHECK (validation_status IN ('ACCEPTED', 'FLAGGED', 'REJECTED')), + validation_reason TEXT, + captured_at TIMESTAMPTZ NOT NULL, + raw_payload JSONB NOT NULL DEFAULT '{}'::jsonb, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE INDEX IF NOT EXISTS idx_attendance_events_assignment_time + ON attendance_events (assignment_id, captured_at DESC); + +CREATE INDEX IF NOT EXISTS idx_attendance_events_staff_time + ON attendance_events (staff_id, captured_at DESC); + +CREATE TABLE IF NOT EXISTS attendance_sessions ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id) ON DELETE CASCADE, + assignment_id UUID NOT NULL UNIQUE REFERENCES assignments(id) ON DELETE CASCADE, + staff_id UUID NOT NULL REFERENCES staffs(id) ON DELETE RESTRICT, + clock_in_event_id UUID REFERENCES attendance_events(id) ON DELETE SET NULL, + clock_out_event_id UUID REFERENCES attendance_events(id) ON DELETE SET NULL, + status TEXT NOT NULL DEFAULT 'OPEN' + CHECK (status IN ('OPEN', 'CLOSED', 'DISPUTED')), + check_in_at TIMESTAMPTZ, + check_out_at TIMESTAMPTZ, + worked_minutes INTEGER NOT NULL DEFAULT 0 CHECK (worked_minutes >= 0), + metadata JSONB NOT NULL DEFAULT '{}'::jsonb, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE TABLE IF NOT EXISTS timesheets ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id) ON DELETE CASCADE, + assignment_id UUID NOT NULL UNIQUE REFERENCES assignments(id) ON DELETE CASCADE, + staff_id UUID NOT NULL REFERENCES staffs(id) ON DELETE RESTRICT, + status TEXT NOT NULL DEFAULT 'PENDING' + CHECK (status IN ('PENDING', 'SUBMITTED', 'APPROVED', 'REJECTED', 'PAID')), + regular_minutes INTEGER NOT NULL DEFAULT 0 CHECK (regular_minutes >= 0), + overtime_minutes INTEGER NOT NULL DEFAULT 0 CHECK (overtime_minutes >= 0), + break_minutes INTEGER NOT NULL DEFAULT 0 CHECK (break_minutes >= 0), + gross_pay_cents BIGINT NOT NULL DEFAULT 0 CHECK (gross_pay_cents >= 0), + metadata JSONB NOT NULL DEFAULT '{}'::jsonb, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE TABLE IF NOT EXISTS documents ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id) ON DELETE CASCADE, + document_type TEXT NOT NULL, + name TEXT NOT NULL, + required_for_role_code TEXT, + metadata JSONB NOT NULL DEFAULT '{}'::jsonb, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_documents_tenant_type_name + ON documents (tenant_id, document_type, name); + +CREATE TABLE IF NOT EXISTS staff_documents ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id) ON DELETE CASCADE, + staff_id UUID NOT NULL REFERENCES staffs(id) ON DELETE CASCADE, + document_id UUID NOT NULL REFERENCES documents(id) ON DELETE CASCADE, + file_uri TEXT, + status TEXT NOT NULL DEFAULT 'PENDING' + CHECK (status IN ('PENDING', 'VERIFIED', 'REJECTED', 'EXPIRED')), + expires_at TIMESTAMPTZ, + metadata JSONB NOT NULL DEFAULT '{}'::jsonb, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_staff_documents_staff_document + ON staff_documents (staff_id, document_id); + +CREATE TABLE IF NOT EXISTS certificates ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id) ON DELETE CASCADE, + staff_id UUID NOT NULL REFERENCES staffs(id) ON DELETE CASCADE, + certificate_type TEXT NOT NULL, + certificate_number TEXT, + issued_at TIMESTAMPTZ, + expires_at TIMESTAMPTZ, + status TEXT NOT NULL DEFAULT 'PENDING' + CHECK (status IN ('PENDING', 'VERIFIED', 'REJECTED', 'EXPIRED')), + metadata JSONB NOT NULL DEFAULT '{}'::jsonb, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE TABLE IF NOT EXISTS verification_jobs ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id) ON DELETE CASCADE, + staff_id UUID REFERENCES staffs(id) ON DELETE SET NULL, + document_id UUID REFERENCES documents(id) ON DELETE SET NULL, + type TEXT NOT NULL, + file_uri TEXT NOT NULL, + status TEXT NOT NULL DEFAULT 'PENDING' + CHECK (status IN ('PENDING', 'PROCESSING', 'AUTO_PASS', 'AUTO_FAIL', 'NEEDS_REVIEW', 'APPROVED', 'REJECTED', 'ERROR')), + idempotency_key TEXT, + provider_name TEXT, + provider_reference TEXT, + confidence NUMERIC(4, 3), + reasons JSONB NOT NULL DEFAULT '[]'::jsonb, + extracted JSONB NOT NULL DEFAULT '{}'::jsonb, + review JSONB NOT NULL DEFAULT '{}'::jsonb, + metadata JSONB NOT NULL DEFAULT '{}'::jsonb, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_verification_jobs_tenant_idempotency + ON verification_jobs (tenant_id, idempotency_key) + WHERE idempotency_key IS NOT NULL; + +CREATE TABLE IF NOT EXISTS verification_reviews ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + verification_job_id UUID NOT NULL REFERENCES verification_jobs(id) ON DELETE CASCADE, + reviewer_user_id TEXT REFERENCES users(id) ON DELETE SET NULL, + decision TEXT NOT NULL CHECK (decision IN ('APPROVED', 'REJECTED')), + note TEXT, + reason_code TEXT, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE TABLE IF NOT EXISTS verification_events ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + verification_job_id UUID NOT NULL REFERENCES verification_jobs(id) ON DELETE CASCADE, + from_status TEXT, + to_status TEXT NOT NULL, + actor_type TEXT NOT NULL, + actor_id TEXT, + details JSONB NOT NULL DEFAULT '{}'::jsonb, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE TABLE IF NOT EXISTS accounts ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id) ON DELETE CASCADE, + owner_type TEXT NOT NULL CHECK (owner_type IN ('BUSINESS', 'VENDOR', 'STAFF')), + owner_business_id UUID REFERENCES businesses(id) ON DELETE CASCADE, + owner_vendor_id UUID REFERENCES vendors(id) ON DELETE CASCADE, + owner_staff_id UUID REFERENCES staffs(id) ON DELETE CASCADE, + provider_name TEXT NOT NULL, + provider_reference TEXT NOT NULL, + last4 TEXT, + is_primary BOOLEAN NOT NULL DEFAULT FALSE, + metadata JSONB NOT NULL DEFAULT '{}'::jsonb, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + CONSTRAINT chk_accounts_single_owner + CHECK ( + (owner_business_id IS NOT NULL)::INTEGER + + (owner_vendor_id IS NOT NULL)::INTEGER + + (owner_staff_id IS NOT NULL)::INTEGER = 1 + ) +); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_accounts_owner_primary_business + ON accounts (owner_business_id) + WHERE owner_business_id IS NOT NULL AND is_primary = TRUE; + +CREATE UNIQUE INDEX IF NOT EXISTS idx_accounts_owner_primary_vendor + ON accounts (owner_vendor_id) + WHERE owner_vendor_id IS NOT NULL AND is_primary = TRUE; + +CREATE UNIQUE INDEX IF NOT EXISTS idx_accounts_owner_primary_staff + ON accounts (owner_staff_id) + WHERE owner_staff_id IS NOT NULL AND is_primary = TRUE; + +CREATE TABLE IF NOT EXISTS invoices ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id) ON DELETE CASCADE, + order_id UUID NOT NULL REFERENCES orders(id) ON DELETE CASCADE, + business_id UUID NOT NULL REFERENCES businesses(id) ON DELETE RESTRICT, + vendor_id UUID REFERENCES vendors(id) ON DELETE SET NULL, + invoice_number TEXT NOT NULL, + status TEXT NOT NULL DEFAULT 'PENDING' + CHECK (status IN ('DRAFT', 'PENDING', 'PENDING_REVIEW', 'APPROVED', 'PAID', 'OVERDUE', 'DISPUTED', 'VOID')), + currency_code TEXT NOT NULL DEFAULT 'USD', + subtotal_cents BIGINT NOT NULL DEFAULT 0 CHECK (subtotal_cents >= 0), + tax_cents BIGINT NOT NULL DEFAULT 0 CHECK (tax_cents >= 0), + total_cents BIGINT NOT NULL DEFAULT 0 CHECK (total_cents >= 0), + due_at TIMESTAMPTZ, + metadata JSONB NOT NULL DEFAULT '{}'::jsonb, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_invoices_tenant_invoice_number + ON invoices (tenant_id, invoice_number); + +CREATE TABLE IF NOT EXISTS recent_payments ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id) ON DELETE CASCADE, + invoice_id UUID NOT NULL REFERENCES invoices(id) ON DELETE CASCADE, + assignment_id UUID REFERENCES assignments(id) ON DELETE SET NULL, + staff_id UUID REFERENCES staffs(id) ON DELETE SET NULL, + status TEXT NOT NULL DEFAULT 'PENDING' + CHECK (status IN ('PENDING', 'PROCESSING', 'PAID', 'FAILED')), + amount_cents BIGINT NOT NULL CHECK (amount_cents >= 0), + process_date TIMESTAMPTZ, + metadata JSONB NOT NULL DEFAULT '{}'::jsonb, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE TABLE IF NOT EXISTS staff_reviews ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id) ON DELETE CASCADE, + business_id UUID NOT NULL REFERENCES businesses(id) ON DELETE CASCADE, + staff_id UUID NOT NULL REFERENCES staffs(id) ON DELETE CASCADE, + assignment_id UUID NOT NULL REFERENCES assignments(id) ON DELETE CASCADE, + reviewer_user_id TEXT REFERENCES users(id) ON DELETE SET NULL, + rating SMALLINT NOT NULL CHECK (rating BETWEEN 1 AND 5), + review_text TEXT, + tags JSONB NOT NULL DEFAULT '[]'::jsonb, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_staff_reviews_business_assignment_staff + ON staff_reviews (business_id, assignment_id, staff_id); + +CREATE INDEX IF NOT EXISTS idx_staff_reviews_staff_created_at + ON staff_reviews (staff_id, created_at DESC); + +CREATE TABLE IF NOT EXISTS staff_favorites ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id) ON DELETE CASCADE, + business_id UUID NOT NULL REFERENCES businesses(id) ON DELETE CASCADE, + staff_id UUID NOT NULL REFERENCES staffs(id) ON DELETE CASCADE, + created_by_user_id TEXT REFERENCES users(id) ON DELETE SET NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_staff_favorites_business_staff + ON staff_favorites (business_id, staff_id); + +CREATE TABLE IF NOT EXISTS domain_events ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + tenant_id UUID NOT NULL REFERENCES tenants(id) ON DELETE CASCADE, + aggregate_type TEXT NOT NULL, + aggregate_id UUID NOT NULL, + sequence INTEGER NOT NULL CHECK (sequence > 0), + event_type TEXT NOT NULL, + actor_user_id TEXT REFERENCES users(id) ON DELETE SET NULL, + payload JSONB NOT NULL DEFAULT '{}'::jsonb, + created_at TIMESTAMPTZ NOT NULL DEFAULT NOW() +); + +CREATE UNIQUE INDEX IF NOT EXISTS idx_domain_events_aggregate_sequence + ON domain_events (tenant_id, aggregate_type, aggregate_id, sequence); diff --git a/backend/command-api/src/app.js b/backend/command-api/src/app.js index c6a72078..ef43071c 100644 --- a/backend/command-api/src/app.js +++ b/backend/command-api/src/app.js @@ -8,7 +8,7 @@ import { createCommandsRouter } from './routes/commands.js'; const logger = pino({ level: process.env.LOG_LEVEL || 'info' }); -export function createApp() { +export function createApp(options = {}) { const app = express(); app.use(requestContext); @@ -21,7 +21,7 @@ export function createApp() { app.use(express.json({ limit: '2mb' })); app.use(healthRouter); - app.use('/commands', createCommandsRouter()); + app.use('/commands', createCommandsRouter(options.commandHandlers)); app.use(notFoundHandler); app.use(errorHandler); diff --git a/backend/command-api/src/contracts/commands/attendance.js b/backend/command-api/src/contracts/commands/attendance.js new file mode 100644 index 00000000..fb797943 --- /dev/null +++ b/backend/command-api/src/contracts/commands/attendance.js @@ -0,0 +1,14 @@ +import { z } from 'zod'; + +export const attendanceCommandSchema = z.object({ + assignmentId: z.string().uuid(), + sourceType: z.enum(['NFC', 'GEO', 'QR', 'MANUAL', 'SYSTEM']), + sourceReference: z.string().max(255).optional(), + nfcTagUid: z.string().max(255).optional(), + deviceId: z.string().max(255).optional(), + latitude: z.number().min(-90).max(90).optional(), + longitude: z.number().min(-180).max(180).optional(), + accuracyMeters: z.number().int().nonnegative().optional(), + capturedAt: z.string().datetime().optional(), + rawPayload: z.record(z.any()).optional(), +}); diff --git a/backend/command-api/src/contracts/commands/favorite-staff.js b/backend/command-api/src/contracts/commands/favorite-staff.js new file mode 100644 index 00000000..f27c9a07 --- /dev/null +++ b/backend/command-api/src/contracts/commands/favorite-staff.js @@ -0,0 +1,7 @@ +import { z } from 'zod'; + +export const favoriteStaffSchema = z.object({ + tenantId: z.string().uuid(), + businessId: z.string().uuid(), + staffId: z.string().uuid(), +}); diff --git a/backend/command-api/src/contracts/commands/order-cancel.js b/backend/command-api/src/contracts/commands/order-cancel.js new file mode 100644 index 00000000..1b1ea3b6 --- /dev/null +++ b/backend/command-api/src/contracts/commands/order-cancel.js @@ -0,0 +1,8 @@ +import { z } from 'zod'; + +export const orderCancelSchema = z.object({ + orderId: z.string().uuid(), + tenantId: z.string().uuid(), + reason: z.string().max(1000).optional(), + metadata: z.record(z.any()).optional(), +}); diff --git a/backend/command-api/src/contracts/commands/order-create.js b/backend/command-api/src/contracts/commands/order-create.js new file mode 100644 index 00000000..3ea5df80 --- /dev/null +++ b/backend/command-api/src/contracts/commands/order-create.js @@ -0,0 +1,57 @@ +import { z } from 'zod'; + +const roleSchema = z.object({ + roleCode: z.string().min(1).max(100), + roleName: z.string().min(1).max(120), + workersNeeded: z.number().int().positive(), + payRateCents: z.number().int().nonnegative().optional(), + billRateCents: z.number().int().nonnegative().optional(), + metadata: z.record(z.any()).optional(), +}); + +const shiftSchema = z.object({ + shiftCode: z.string().min(1).max(80), + title: z.string().min(1).max(160), + status: z.enum([ + 'DRAFT', + 'OPEN', + 'PENDING_CONFIRMATION', + 'ASSIGNED', + 'ACTIVE', + 'COMPLETED', + 'CANCELLED', + ]).optional(), + startsAt: z.string().datetime(), + endsAt: z.string().datetime(), + timezone: z.string().min(1).max(80).optional(), + clockPointId: z.string().uuid().optional(), + locationName: z.string().max(160).optional(), + locationAddress: z.string().max(300).optional(), + latitude: z.number().min(-90).max(90).optional(), + longitude: z.number().min(-180).max(180).optional(), + geofenceRadiusMeters: z.number().int().positive().optional(), + requiredWorkers: z.number().int().positive(), + notes: z.string().max(5000).optional(), + metadata: z.record(z.any()).optional(), + roles: z.array(roleSchema).min(1), +}); + +export const orderCreateSchema = z.object({ + tenantId: z.string().uuid(), + businessId: z.string().uuid(), + vendorId: z.string().uuid().optional(), + orderNumber: z.string().min(1).max(80), + title: z.string().min(1).max(160), + description: z.string().max(5000).optional(), + status: z.enum(['DRAFT', 'OPEN', 'FILLED', 'ACTIVE', 'COMPLETED', 'CANCELLED']).optional(), + serviceType: z.enum(['EVENT', 'CATERING', 'HOTEL', 'RESTAURANT', 'OTHER']).optional(), + startsAt: z.string().datetime().optional(), + endsAt: z.string().datetime().optional(), + locationName: z.string().max(160).optional(), + locationAddress: z.string().max(300).optional(), + latitude: z.number().min(-90).max(90).optional(), + longitude: z.number().min(-180).max(180).optional(), + notes: z.string().max(5000).optional(), + metadata: z.record(z.any()).optional(), + shifts: z.array(shiftSchema).min(1), +}); diff --git a/backend/command-api/src/contracts/commands/order-update.js b/backend/command-api/src/contracts/commands/order-update.js new file mode 100644 index 00000000..1eb039f1 --- /dev/null +++ b/backend/command-api/src/contracts/commands/order-update.js @@ -0,0 +1,35 @@ +import { z } from 'zod'; + +const nullableString = (max) => z.union([z.string().max(max), z.null()]); +const nullableDateTime = z.union([z.string().datetime(), z.null()]); +const nullableUuid = z.union([z.string().uuid(), z.null()]); + +const orderUpdateShape = { + orderId: z.string().uuid(), + tenantId: z.string().uuid(), + vendorId: nullableUuid.optional(), + title: nullableString(160).optional(), + description: nullableString(5000).optional(), + status: z.enum(['DRAFT', 'OPEN', 'FILLED', 'ACTIVE', 'COMPLETED']).optional(), + serviceType: z.enum(['EVENT', 'CATERING', 'HOTEL', 'RESTAURANT', 'OTHER']).optional(), + startsAt: nullableDateTime.optional(), + endsAt: nullableDateTime.optional(), + locationName: nullableString(160).optional(), + locationAddress: nullableString(300).optional(), + latitude: z.union([z.number().min(-90).max(90), z.null()]).optional(), + longitude: z.union([z.number().min(-180).max(180), z.null()]).optional(), + notes: nullableString(5000).optional(), + metadata: z.record(z.any()).optional(), +}; + +export const orderUpdateSchema = z.object(orderUpdateShape).superRefine((value, ctx) => { + const mutableKeys = Object.keys(orderUpdateShape).filter((key) => !['orderId', 'tenantId'].includes(key)); + const hasMutableField = mutableKeys.some((key) => Object.prototype.hasOwnProperty.call(value, key)); + if (!hasMutableField) { + ctx.addIssue({ + code: z.ZodIssueCode.custom, + message: 'At least one mutable order field must be provided', + path: [], + }); + } +}); diff --git a/backend/command-api/src/contracts/commands/shift-accept.js b/backend/command-api/src/contracts/commands/shift-accept.js new file mode 100644 index 00000000..19d29d3c --- /dev/null +++ b/backend/command-api/src/contracts/commands/shift-accept.js @@ -0,0 +1,8 @@ +import { z } from 'zod'; + +export const shiftAcceptSchema = z.object({ + shiftId: z.string().uuid().optional(), + shiftRoleId: z.string().uuid(), + workforceId: z.string().uuid(), + metadata: z.record(z.any()).optional(), +}); diff --git a/backend/command-api/src/contracts/commands/shift-assign-staff.js b/backend/command-api/src/contracts/commands/shift-assign-staff.js new file mode 100644 index 00000000..2df3af81 --- /dev/null +++ b/backend/command-api/src/contracts/commands/shift-assign-staff.js @@ -0,0 +1,10 @@ +import { z } from 'zod'; + +export const shiftAssignStaffSchema = z.object({ + shiftId: z.string().uuid(), + tenantId: z.string().uuid(), + shiftRoleId: z.string().uuid(), + workforceId: z.string().uuid(), + applicationId: z.string().uuid().optional(), + metadata: z.record(z.any()).optional(), +}); diff --git a/backend/command-api/src/contracts/commands/shift-status-change.js b/backend/command-api/src/contracts/commands/shift-status-change.js new file mode 100644 index 00000000..296c7877 --- /dev/null +++ b/backend/command-api/src/contracts/commands/shift-status-change.js @@ -0,0 +1,17 @@ +import { z } from 'zod'; + +export const shiftStatusChangeSchema = z.object({ + shiftId: z.string().uuid(), + tenantId: z.string().uuid(), + status: z.enum([ + 'DRAFT', + 'OPEN', + 'PENDING_CONFIRMATION', + 'ASSIGNED', + 'ACTIVE', + 'COMPLETED', + 'CANCELLED', + ]), + reason: z.string().max(1000).optional(), + metadata: z.record(z.any()).optional(), +}); diff --git a/backend/command-api/src/contracts/commands/staff-review.js b/backend/command-api/src/contracts/commands/staff-review.js new file mode 100644 index 00000000..d53e1ca6 --- /dev/null +++ b/backend/command-api/src/contracts/commands/staff-review.js @@ -0,0 +1,11 @@ +import { z } from 'zod'; + +export const staffReviewSchema = z.object({ + tenantId: z.string().uuid(), + businessId: z.string().uuid(), + staffId: z.string().uuid(), + assignmentId: z.string().uuid(), + rating: z.number().int().min(1).max(5), + reviewText: z.string().max(5000).optional(), + tags: z.array(z.string().min(1).max(80)).max(20).optional(), +}); diff --git a/backend/command-api/src/routes/commands.js b/backend/command-api/src/routes/commands.js index a16d23da..5fc82c10 100644 --- a/backend/command-api/src/routes/commands.js +++ b/backend/command-api/src/routes/commands.js @@ -3,10 +3,45 @@ import { AppError } from '../lib/errors.js'; import { requireAuth, requirePolicy } from '../middleware/auth.js'; import { requireIdempotencyKey } from '../middleware/idempotency.js'; import { buildIdempotencyKey, readIdempotentResult, writeIdempotentResult } from '../services/idempotency-store.js'; -import { commandBaseSchema } from '../contracts/commands/command-base.js'; +import { + addFavoriteStaff, + clockIn, + clockOut, + createOrder, + createStaffReview, + updateOrder, + cancelOrder, + changeShiftStatus, + assignStaffToShift, + removeFavoriteStaff, + acceptShift, +} from '../services/command-service.js'; +import { attendanceCommandSchema } from '../contracts/commands/attendance.js'; +import { favoriteStaffSchema } from '../contracts/commands/favorite-staff.js'; +import { orderCancelSchema } from '../contracts/commands/order-cancel.js'; +import { orderCreateSchema } from '../contracts/commands/order-create.js'; +import { orderUpdateSchema } from '../contracts/commands/order-update.js'; +import { shiftAssignStaffSchema } from '../contracts/commands/shift-assign-staff.js'; +import { shiftAcceptSchema } from '../contracts/commands/shift-accept.js'; +import { shiftStatusChangeSchema } from '../contracts/commands/shift-status-change.js'; +import { staffReviewSchema } from '../contracts/commands/staff-review.js'; -function parseBody(body) { - const parsed = commandBaseSchema.safeParse(body || {}); +const defaultHandlers = { + addFavoriteStaff, + assignStaffToShift, + cancelOrder, + changeShiftStatus, + clockIn, + clockOut, + createOrder, + createStaffReview, + removeFavoriteStaff, + acceptShift, + updateOrder, +}; + +function parseBody(schema, body) { + const parsed = schema.safeParse(body || {}); if (!parsed.success) { throw new AppError('VALIDATION_ERROR', 'Invalid command payload', 400, { issues: parsed.error.issues, @@ -15,50 +50,37 @@ function parseBody(body) { return parsed.data; } -function createCommandResponse(route, requestId, idempotencyKey) { - return { - accepted: true, +async function runIdempotentCommand(req, res, work) { + const route = `${req.baseUrl}${req.route.path}`; + const compositeKey = buildIdempotencyKey({ + userId: req.actor.uid, route, - commandId: `${route}:${Date.now()}`, - idempotencyKey, - requestId, + idempotencyKey: req.idempotencyKey, + }); + + const existing = await readIdempotentResult(compositeKey); + if (existing) { + return res.status(existing.statusCode).json(existing.payload); + } + + const payload = await work(); + const responsePayload = { + ...payload, + idempotencyKey: req.idempotencyKey, + requestId: req.requestId, }; + const persisted = await writeIdempotentResult({ + compositeKey, + userId: req.actor.uid, + route, + idempotencyKey: req.idempotencyKey, + payload: responsePayload, + statusCode: 200, + }); + return res.status(persisted.statusCode).json(persisted.payload); } -function buildCommandHandler(policyAction, policyResource) { - return async (req, res, next) => { - try { - parseBody(req.body); - - const route = `${req.baseUrl}${req.route.path}`; - const compositeKey = buildIdempotencyKey({ - userId: req.actor.uid, - route, - idempotencyKey: req.idempotencyKey, - }); - - const existing = await readIdempotentResult(compositeKey); - if (existing) { - return res.status(existing.statusCode).json(existing.payload); - } - - const payload = createCommandResponse(route, req.requestId, req.idempotencyKey); - const persisted = await writeIdempotentResult({ - compositeKey, - userId: req.actor.uid, - route, - idempotencyKey: req.idempotencyKey, - payload, - statusCode: 200, - }); - return res.status(persisted.statusCode).json(persisted.payload); - } catch (error) { - return next(error); - } - }; -} - -export function createCommandsRouter() { +export function createCommandsRouter(handlers = defaultHandlers) { const router = Router(); router.post( @@ -66,7 +88,14 @@ export function createCommandsRouter() { requireAuth, requireIdempotencyKey, requirePolicy('orders.create', 'order'), - buildCommandHandler('orders.create', 'order') + async (req, res, next) => { + try { + const payload = parseBody(orderCreateSchema, req.body); + return await runIdempotentCommand(req, res, () => handlers.createOrder(req.actor, payload)); + } catch (error) { + return next(error); + } + } ); router.post( @@ -74,7 +103,17 @@ export function createCommandsRouter() { requireAuth, requireIdempotencyKey, requirePolicy('orders.update', 'order'), - buildCommandHandler('orders.update', 'order') + async (req, res, next) => { + try { + const payload = parseBody(orderUpdateSchema, { + ...req.body, + orderId: req.params.orderId, + }); + return await runIdempotentCommand(req, res, () => handlers.updateOrder(req.actor, payload)); + } catch (error) { + return next(error); + } + } ); router.post( @@ -82,7 +121,17 @@ export function createCommandsRouter() { requireAuth, requireIdempotencyKey, requirePolicy('orders.cancel', 'order'), - buildCommandHandler('orders.cancel', 'order') + async (req, res, next) => { + try { + const payload = parseBody(orderCancelSchema, { + ...req.body, + orderId: req.params.orderId, + }); + return await runIdempotentCommand(req, res, () => handlers.cancelOrder(req.actor, payload)); + } catch (error) { + return next(error); + } + } ); router.post( @@ -90,7 +139,17 @@ export function createCommandsRouter() { requireAuth, requireIdempotencyKey, requirePolicy('shifts.change-status', 'shift'), - buildCommandHandler('shifts.change-status', 'shift') + async (req, res, next) => { + try { + const payload = parseBody(shiftStatusChangeSchema, { + ...req.body, + shiftId: req.params.shiftId, + }); + return await runIdempotentCommand(req, res, () => handlers.changeShiftStatus(req.actor, payload)); + } catch (error) { + return next(error); + } + } ); router.post( @@ -98,7 +157,17 @@ export function createCommandsRouter() { requireAuth, requireIdempotencyKey, requirePolicy('shifts.assign-staff', 'shift'), - buildCommandHandler('shifts.assign-staff', 'shift') + async (req, res, next) => { + try { + const payload = parseBody(shiftAssignStaffSchema, { + ...req.body, + shiftId: req.params.shiftId, + }); + return await runIdempotentCommand(req, res, () => handlers.assignStaffToShift(req.actor, payload)); + } catch (error) { + return next(error); + } + } ); router.post( @@ -106,7 +175,102 @@ export function createCommandsRouter() { requireAuth, requireIdempotencyKey, requirePolicy('shifts.accept', 'shift'), - buildCommandHandler('shifts.accept', 'shift') + async (req, res, next) => { + try { + const payload = parseBody(shiftAcceptSchema, { + ...req.body, + shiftId: req.params.shiftId, + }); + return await runIdempotentCommand(req, res, () => handlers.acceptShift(req.actor, payload)); + } catch (error) { + return next(error); + } + } + ); + + router.post( + '/attendance/clock-in', + requireAuth, + requireIdempotencyKey, + requirePolicy('attendance.clock-in', 'attendance'), + async (req, res, next) => { + try { + const payload = parseBody(attendanceCommandSchema, req.body); + return await runIdempotentCommand(req, res, () => handlers.clockIn(req.actor, payload)); + } catch (error) { + return next(error); + } + } + ); + + router.post( + '/attendance/clock-out', + requireAuth, + requireIdempotencyKey, + requirePolicy('attendance.clock-out', 'attendance'), + async (req, res, next) => { + try { + const payload = parseBody(attendanceCommandSchema, req.body); + return await runIdempotentCommand(req, res, () => handlers.clockOut(req.actor, payload)); + } catch (error) { + return next(error); + } + } + ); + + router.post( + '/businesses/:businessId/favorite-staff', + requireAuth, + requireIdempotencyKey, + requirePolicy('business.favorite-staff', 'staff'), + async (req, res, next) => { + try { + const payload = parseBody(favoriteStaffSchema, { + ...req.body, + businessId: req.params.businessId, + }); + return await runIdempotentCommand(req, res, () => handlers.addFavoriteStaff(req.actor, payload)); + } catch (error) { + return next(error); + } + } + ); + + router.delete( + '/businesses/:businessId/favorite-staff/:staffId', + requireAuth, + requireIdempotencyKey, + requirePolicy('business.unfavorite-staff', 'staff'), + async (req, res, next) => { + try { + const payload = parseBody(favoriteStaffSchema, { + ...req.body, + businessId: req.params.businessId, + staffId: req.params.staffId, + }); + return await runIdempotentCommand(req, res, () => handlers.removeFavoriteStaff(req.actor, payload)); + } catch (error) { + return next(error); + } + } + ); + + router.post( + '/assignments/:assignmentId/reviews', + requireAuth, + requireIdempotencyKey, + requirePolicy('assignments.review-staff', 'assignment'), + async (req, res, next) => { + try { + const payload = parseBody(staffReviewSchema, { + ...req.body, + assignmentId: req.params.assignmentId, + }); + return await runIdempotentCommand(req, res, () => handlers.createStaffReview(req.actor, payload)); + } catch (error) { + return next(error); + } + } ); return router; diff --git a/backend/command-api/src/routes/health.js b/backend/command-api/src/routes/health.js index 90cd5690..4dbbdca0 100644 --- a/backend/command-api/src/routes/health.js +++ b/backend/command-api/src/routes/health.js @@ -1,4 +1,5 @@ import { Router } from 'express'; +import { checkDatabaseHealth, isDatabaseConfigured } from '../services/db.js'; export const healthRouter = Router(); @@ -13,3 +14,32 @@ function healthHandler(req, res) { healthRouter.get('/health', healthHandler); healthRouter.get('/healthz', healthHandler); + +healthRouter.get('/readyz', async (req, res) => { + if (!isDatabaseConfigured()) { + return res.status(503).json({ + ok: false, + service: 'krow-command-api', + status: 'DATABASE_NOT_CONFIGURED', + requestId: req.requestId, + }); + } + + try { + const ok = await checkDatabaseHealth(); + return res.status(ok ? 200 : 503).json({ + ok, + service: 'krow-command-api', + status: ok ? 'READY' : 'DATABASE_UNAVAILABLE', + requestId: req.requestId, + }); + } catch (error) { + return res.status(503).json({ + ok: false, + service: 'krow-command-api', + status: 'DATABASE_UNAVAILABLE', + details: { message: error.message }, + requestId: req.requestId, + }); + } +}); diff --git a/backend/command-api/src/services/command-service.js b/backend/command-api/src/services/command-service.js new file mode 100644 index 00000000..e1aa5ca0 --- /dev/null +++ b/backend/command-api/src/services/command-service.js @@ -0,0 +1,1553 @@ +import { AppError } from '../lib/errors.js'; +import { withTransaction } from './db.js'; + +function toIsoOrNull(value) { + return value ? new Date(value).toISOString() : null; +} + +function toRadians(value) { + return (value * Math.PI) / 180; +} + +function distanceMeters(from, to) { + if ( + from?.latitude == null + || from?.longitude == null + || to?.latitude == null + || to?.longitude == null + ) { + return null; + } + + const earthRadiusMeters = 6371000; + const dLat = toRadians(Number(to.latitude) - Number(from.latitude)); + const dLon = toRadians(Number(to.longitude) - Number(from.longitude)); + const lat1 = toRadians(Number(from.latitude)); + const lat2 = toRadians(Number(to.latitude)); + + const a = Math.sin(dLat / 2) ** 2 + + Math.cos(lat1) * Math.cos(lat2) * Math.sin(dLon / 2) ** 2; + const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)); + return Math.round(earthRadiusMeters * c); +} + +const ACTIVE_ASSIGNMENT_STATUSES = new Set([ + 'ASSIGNED', + 'ACCEPTED', + 'CHECKED_IN', + 'CHECKED_OUT', + 'COMPLETED', +]); + +const CANCELLABLE_ASSIGNMENT_STATUSES = ['ASSIGNED', 'ACCEPTED']; +const CANCELLABLE_APPLICATION_STATUSES = ['PENDING', 'CONFIRMED']; + +const SHIFT_STATUS_TRANSITIONS = { + DRAFT: new Set(['OPEN', 'CANCELLED']), + OPEN: new Set(['PENDING_CONFIRMATION', 'ASSIGNED', 'ACTIVE', 'CANCELLED']), + PENDING_CONFIRMATION: new Set(['ASSIGNED', 'CANCELLED']), + ASSIGNED: new Set(['ACTIVE', 'COMPLETED', 'CANCELLED']), + ACTIVE: new Set(['COMPLETED', 'CANCELLED']), + COMPLETED: new Set([]), + CANCELLED: new Set([]), +}; + +async function ensureActorUser(client, actor) { + await client.query( + ` + INSERT INTO users (id, email, display_name, status) + VALUES ($1, $2, $3, 'ACTIVE') + ON CONFLICT (id) DO UPDATE + SET email = COALESCE(EXCLUDED.email, users.email), + display_name = COALESCE(EXCLUDED.display_name, users.display_name), + updated_at = NOW() + `, + [actor.uid, actor.email, actor.email] + ); +} + +async function insertDomainEvent(client, { + tenantId, + aggregateType, + aggregateId, + eventType, + actorUserId, + payload, +}) { + await client.query( + ` + INSERT INTO domain_events ( + tenant_id, + aggregate_type, + aggregate_id, + sequence, + event_type, + actor_user_id, + payload + ) + SELECT + $1, + $2, + $3, + COALESCE(MAX(sequence) + 1, 1), + $4, + $5, + $6::jsonb + FROM domain_events + WHERE tenant_id = $1 + AND aggregate_type = $2 + AND aggregate_id = $3 + `, + [tenantId, aggregateType, aggregateId, eventType, actorUserId, JSON.stringify(payload || {})] + ); +} + +async function requireBusiness(client, tenantId, businessId) { + const result = await client.query( + ` + SELECT id, business_name + FROM businesses + WHERE id = $1 AND tenant_id = $2 + `, + [businessId, tenantId] + ); + if (result.rowCount === 0) { + throw new AppError('NOT_FOUND', 'Business not found in tenant scope', 404, { + tenantId, + businessId, + }); + } + return result.rows[0]; +} + +async function requireVendor(client, tenantId, vendorId) { + const result = await client.query( + ` + SELECT id, company_name + FROM vendors + WHERE id = $1 AND tenant_id = $2 + `, + [vendorId, tenantId] + ); + if (result.rowCount === 0) { + throw new AppError('NOT_FOUND', 'Vendor not found in tenant scope', 404, { + tenantId, + vendorId, + }); + } + return result.rows[0]; +} + +async function requireShiftRole(client, shiftRoleId) { + const result = await client.query( + ` + SELECT sr.id, + sr.shift_id, + sr.role_code, + sr.role_name, + sr.workers_needed, + sr.assigned_count, + s.tenant_id, + s.business_id, + s.vendor_id + FROM shift_roles sr + JOIN shifts s ON s.id = sr.shift_id + WHERE sr.id = $1 + FOR UPDATE + `, + [shiftRoleId] + ); + if (result.rowCount === 0) { + throw new AppError('NOT_FOUND', 'Shift role not found', 404, { shiftRoleId }); + } + return result.rows[0]; +} + +async function requireAssignment(client, assignmentId) { + const result = await client.query( + ` + SELECT a.id, + a.tenant_id, + a.business_id, + a.vendor_id, + a.shift_id, + a.shift_role_id, + a.workforce_id, + a.staff_id, + a.status, + s.clock_point_id, + s.title AS shift_title, + s.starts_at, + s.ends_at, + cp.nfc_tag_uid AS expected_nfc_tag_uid, + cp.latitude AS expected_latitude, + cp.longitude AS expected_longitude, + cp.geofence_radius_meters + FROM assignments a + JOIN shifts s ON s.id = a.shift_id + LEFT JOIN clock_points cp ON cp.id = s.clock_point_id + WHERE a.id = $1 + FOR UPDATE OF a, s + `, + [assignmentId] + ); + if (result.rowCount === 0) { + throw new AppError('NOT_FOUND', 'Assignment not found', 404, { assignmentId }); + } + return result.rows[0]; +} + +async function requireOrder(client, tenantId, orderId) { + const result = await client.query( + ` + SELECT id, + tenant_id, + business_id, + vendor_id, + order_number, + status, + starts_at, + ends_at + FROM orders + WHERE id = $1 + AND tenant_id = $2 + FOR UPDATE + `, + [orderId, tenantId] + ); + + if (result.rowCount === 0) { + throw new AppError('NOT_FOUND', 'Order not found in tenant scope', 404, { + tenantId, + orderId, + }); + } + + return result.rows[0]; +} + +async function requireShift(client, tenantId, shiftId) { + const result = await client.query( + ` + SELECT id, + tenant_id, + order_id, + business_id, + vendor_id, + status, + starts_at, + ends_at, + required_workers, + assigned_workers + FROM shifts + WHERE id = $1 + AND tenant_id = $2 + FOR UPDATE + `, + [shiftId, tenantId] + ); + + if (result.rowCount === 0) { + throw new AppError('NOT_FOUND', 'Shift not found in tenant scope', 404, { + tenantId, + shiftId, + }); + } + + return result.rows[0]; +} + +async function requireWorkforce(client, tenantId, workforceId) { + const result = await client.query( + ` + SELECT id, tenant_id, vendor_id, staff_id, status + FROM workforce + WHERE id = $1 + AND tenant_id = $2 + AND status = 'ACTIVE' + `, + [workforceId, tenantId] + ); + + if (result.rowCount === 0) { + throw new AppError('NOT_FOUND', 'Workforce record not found', 404, { + tenantId, + workforceId, + }); + } + + return result.rows[0]; +} + +async function findAssignmentForShiftRoleWorkforce(client, shiftRoleId, workforceId) { + const result = await client.query( + ` + SELECT id, + tenant_id, + shift_id, + shift_role_id, + workforce_id, + staff_id, + application_id, + status + FROM assignments + WHERE shift_role_id = $1 + AND workforce_id = $2 + FOR UPDATE + `, + [shiftRoleId, workforceId] + ); + + return result.rows[0] || null; +} + +async function requireApplication(client, tenantId, applicationId) { + const result = await client.query( + ` + SELECT id, + tenant_id, + shift_id, + shift_role_id, + staff_id, + status + FROM applications + WHERE id = $1 + AND tenant_id = $2 + FOR UPDATE + `, + [applicationId, tenantId] + ); + + if (result.rowCount === 0) { + throw new AppError('NOT_FOUND', 'Application not found in tenant scope', 404, { + tenantId, + applicationId, + }); + } + + return result.rows[0]; +} + +async function refreshShiftRoleCounts(client, shiftRoleId) { + await client.query( + ` + UPDATE shift_roles sr + SET assigned_count = counts.assigned_count, + updated_at = NOW() + FROM ( + SELECT $1::uuid AS shift_role_id, + COUNT(*) FILTER ( + WHERE status IN ('ASSIGNED', 'ACCEPTED', 'CHECKED_IN', 'CHECKED_OUT', 'COMPLETED') + )::INTEGER AS assigned_count + FROM assignments + WHERE shift_role_id = $1 + ) counts + WHERE sr.id = counts.shift_role_id + `, + [shiftRoleId] + ); +} + +async function refreshShiftCounts(client, shiftId) { + await client.query( + ` + UPDATE shifts s + SET assigned_workers = counts.assigned_workers, + updated_at = NOW() + FROM ( + SELECT $1::uuid AS shift_id, + COUNT(*) FILTER ( + WHERE status IN ('ASSIGNED', 'ACCEPTED', 'CHECKED_IN', 'CHECKED_OUT', 'COMPLETED') + )::INTEGER AS assigned_workers + FROM assignments + WHERE shift_id = $1 + ) counts + WHERE s.id = counts.shift_id + `, + [shiftId] + ); +} + +async function transitionShiftStatus(client, shiftId, fromStatus, toStatus) { + if (fromStatus === toStatus) { + return toStatus; + } + + const allowed = SHIFT_STATUS_TRANSITIONS[fromStatus] || new Set(); + if (!allowed.has(toStatus)) { + throw new AppError('INVALID_SHIFT_STATUS_TRANSITION', 'Invalid shift status transition', 409, { + shiftId, + fromStatus, + toStatus, + }); + } + + await client.query( + ` + UPDATE shifts + SET status = $2, + updated_at = NOW() + WHERE id = $1 + `, + [shiftId, toStatus] + ); + + return toStatus; +} + +function assertChronologicalWindow(startsAt, endsAt, code = 'VALIDATION_ERROR') { + if (startsAt && endsAt && new Date(startsAt) >= new Date(endsAt)) { + throw new AppError(code, 'start time must be earlier than end time', 400); + } +} + +function buildOrderUpdateStatement(payload) { + const fieldSpecs = [ + ['vendorId', 'vendor_id', (value) => value], + ['title', 'title', (value) => value], + ['description', 'description', (value) => value], + ['status', 'status', (value) => value], + ['serviceType', 'service_type', (value) => value], + ['startsAt', 'starts_at', (value) => toIsoOrNull(value)], + ['endsAt', 'ends_at', (value) => toIsoOrNull(value)], + ['locationName', 'location_name', (value) => value], + ['locationAddress', 'location_address', (value) => value], + ['latitude', 'latitude', (value) => value], + ['longitude', 'longitude', (value) => value], + ['notes', 'notes', (value) => value], + ['metadata', 'metadata', (value) => JSON.stringify(value || {})], + ]; + + const updates = []; + const values = []; + + for (const [inputKey, column, transform] of fieldSpecs) { + if (!Object.prototype.hasOwnProperty.call(payload, inputKey)) { + continue; + } + values.push(transform(payload[inputKey])); + const placeholder = `$${values.length}`; + updates.push( + column === 'metadata' + ? `${column} = ${placeholder}::jsonb` + : `${column} = ${placeholder}` + ); + } + + if (updates.length === 0) { + throw new AppError('VALIDATION_ERROR', 'At least one mutable order field must be provided', 400); + } + + updates.push('updated_at = NOW()'); + return { updates, values }; +} + +export async function createOrder(actor, payload) { + return withTransaction(async (client) => { + await ensureActorUser(client, actor); + await requireBusiness(client, payload.tenantId, payload.businessId); + if (payload.vendorId) { + await requireVendor(client, payload.tenantId, payload.vendorId); + } + + const orderResult = await client.query( + ` + INSERT INTO orders ( + tenant_id, + business_id, + vendor_id, + order_number, + title, + description, + status, + service_type, + starts_at, + ends_at, + location_name, + location_address, + latitude, + longitude, + notes, + created_by_user_id, + metadata + ) + VALUES ( + $1, $2, $3, $4, $5, $6, COALESCE($7, 'OPEN'), COALESCE($8, 'EVENT'), + $9, $10, $11, $12, $13, $14, $15, $16, $17::jsonb + ) + RETURNING id, order_number, status + `, + [ + payload.tenantId, + payload.businessId, + payload.vendorId || null, + payload.orderNumber, + payload.title, + payload.description || null, + payload.status || null, + payload.serviceType || null, + toIsoOrNull(payload.startsAt), + toIsoOrNull(payload.endsAt), + payload.locationName || null, + payload.locationAddress || null, + payload.latitude ?? null, + payload.longitude ?? null, + payload.notes || null, + actor.uid, + JSON.stringify(payload.metadata || {}), + ] + ); + + const order = orderResult.rows[0]; + const createdShifts = []; + + for (const shiftInput of payload.shifts) { + const shiftResult = await client.query( + ` + INSERT INTO shifts ( + tenant_id, + order_id, + business_id, + vendor_id, + clock_point_id, + shift_code, + title, + status, + starts_at, + ends_at, + timezone, + location_name, + location_address, + latitude, + longitude, + geofence_radius_meters, + required_workers, + assigned_workers, + notes, + metadata + ) + VALUES ( + $1, $2, $3, $4, $5, $6, $7, COALESCE($8, 'OPEN'), $9, $10, COALESCE($11, 'UTC'), + $12, $13, $14, $15, $16, $17, 0, $18, $19::jsonb + ) + RETURNING id, shift_code, title, required_workers + `, + [ + payload.tenantId, + order.id, + payload.businessId, + payload.vendorId || null, + shiftInput.clockPointId || null, + shiftInput.shiftCode, + shiftInput.title, + shiftInput.status || null, + toIsoOrNull(shiftInput.startsAt), + toIsoOrNull(shiftInput.endsAt), + shiftInput.timezone || null, + shiftInput.locationName || payload.locationName || null, + shiftInput.locationAddress || payload.locationAddress || null, + shiftInput.latitude ?? payload.latitude ?? null, + shiftInput.longitude ?? payload.longitude ?? null, + shiftInput.geofenceRadiusMeters ?? null, + shiftInput.requiredWorkers, + shiftInput.notes || null, + JSON.stringify(shiftInput.metadata || {}), + ] + ); + + const shift = shiftResult.rows[0]; + + for (const roleInput of shiftInput.roles) { + await client.query( + ` + INSERT INTO shift_roles ( + shift_id, + role_code, + role_name, + workers_needed, + assigned_count, + pay_rate_cents, + bill_rate_cents, + metadata + ) + VALUES ($1, $2, $3, $4, 0, $5, $6, $7::jsonb) + `, + [ + shift.id, + roleInput.roleCode, + roleInput.roleName, + roleInput.workersNeeded, + roleInput.payRateCents || 0, + roleInput.billRateCents || 0, + JSON.stringify(roleInput.metadata || {}), + ] + ); + } + + createdShifts.push(shift); + } + + await insertDomainEvent(client, { + tenantId: payload.tenantId, + aggregateType: 'order', + aggregateId: order.id, + eventType: 'ORDER_CREATED', + actorUserId: actor.uid, + payload: { + orderId: order.id, + shiftCount: createdShifts.length, + }, + }); + + return { + orderId: order.id, + orderNumber: order.order_number, + status: order.status, + shiftCount: createdShifts.length, + shiftIds: createdShifts.map((shift) => shift.id), + }; + }); +} + +export async function acceptShift(actor, payload) { + return withTransaction(async (client) => { + await ensureActorUser(client, actor); + + const shiftRole = await requireShiftRole(client, payload.shiftRoleId); + if (payload.shiftId && shiftRole.shift_id !== payload.shiftId) { + throw new AppError('VALIDATION_ERROR', 'shiftId does not match shiftRoleId', 400, { + shiftId: payload.shiftId, + shiftRoleId: payload.shiftRoleId, + }); + } + + if (shiftRole.assigned_count >= shiftRole.workers_needed) { + const existingFilledAssignment = await findAssignmentForShiftRoleWorkforce( + client, + shiftRole.id, + payload.workforceId + ); + if (!existingFilledAssignment || existingFilledAssignment.status === 'CANCELLED') { + throw new AppError('SHIFT_ROLE_FILLED', 'Shift role is already filled', 409, { + shiftRoleId: payload.shiftRoleId, + }); + } + } + + const workforce = await requireWorkforce(client, shiftRole.tenant_id, payload.workforceId); + const existingAssignment = await findAssignmentForShiftRoleWorkforce(client, shiftRole.id, workforce.id); + + let assignment; + if (existingAssignment) { + if (existingAssignment.status === 'CANCELLED') { + throw new AppError('ASSIGNMENT_CANCELLED', 'Cancelled assignment cannot be accepted', 409, { + assignmentId: existingAssignment.id, + }); + } + + if (['ACCEPTED', 'CHECKED_IN', 'CHECKED_OUT', 'COMPLETED'].includes(existingAssignment.status)) { + assignment = existingAssignment; + } else { + const updatedAssignment = await client.query( + ` + UPDATE assignments + SET status = 'ACCEPTED', + accepted_at = COALESCE(accepted_at, NOW()), + metadata = COALESCE(metadata, '{}'::jsonb) || $2::jsonb, + updated_at = NOW() + WHERE id = $1 + RETURNING id, status + `, + [existingAssignment.id, JSON.stringify(payload.metadata || {})] + ); + assignment = updatedAssignment.rows[0]; + } + } else { + const assignmentResult = await client.query( + ` + INSERT INTO assignments ( + tenant_id, + business_id, + vendor_id, + shift_id, + shift_role_id, + workforce_id, + staff_id, + status, + assigned_at, + accepted_at, + metadata + ) + VALUES ($1, $2, $3, $4, $5, $6, $7, 'ACCEPTED', NOW(), NOW(), $8::jsonb) + RETURNING id, status + `, + [ + shiftRole.tenant_id, + shiftRole.business_id, + shiftRole.vendor_id, + shiftRole.shift_id, + shiftRole.id, + workforce.id, + workforce.staff_id, + JSON.stringify(payload.metadata || {}), + ] + ); + assignment = assignmentResult.rows[0]; + } + + await refreshShiftRoleCounts(client, shiftRole.id); + await refreshShiftCounts(client, shiftRole.shift_id); + + const shift = await requireShift(client, shiftRole.tenant_id, shiftRole.shift_id); + if (['OPEN', 'PENDING_CONFIRMATION'].includes(shift.status)) { + await transitionShiftStatus(client, shift.id, shift.status, 'ASSIGNED'); + } + + await insertDomainEvent(client, { + tenantId: shiftRole.tenant_id, + aggregateType: 'assignment', + aggregateId: assignment.id, + eventType: 'SHIFT_ACCEPTED', + actorUserId: actor.uid, + payload: { + shiftId: shiftRole.shift_id, + shiftRoleId: shiftRole.id, + workforceId: workforce.id, + }, + }); + + return { + assignmentId: assignment.id, + shiftId: shiftRole.shift_id, + shiftRoleId: shiftRole.id, + status: assignment.status, + }; + }); +} + +export async function updateOrder(actor, payload) { + return withTransaction(async (client) => { + await ensureActorUser(client, actor); + const existingOrder = await requireOrder(client, payload.tenantId, payload.orderId); + + if (Object.prototype.hasOwnProperty.call(payload, 'vendorId') && payload.vendorId) { + await requireVendor(client, payload.tenantId, payload.vendorId); + } + + const nextStartsAt = Object.prototype.hasOwnProperty.call(payload, 'startsAt') + ? payload.startsAt + : existingOrder.starts_at; + const nextEndsAt = Object.prototype.hasOwnProperty.call(payload, 'endsAt') + ? payload.endsAt + : existingOrder.ends_at; + assertChronologicalWindow(nextStartsAt, nextEndsAt); + + const { updates, values } = buildOrderUpdateStatement(payload); + values.push(payload.orderId, payload.tenantId); + const orderResult = await client.query( + ` + UPDATE orders + SET ${updates.join(', ')} + WHERE id = $${values.length - 1} + AND tenant_id = $${values.length} + RETURNING id, order_number, status, updated_at + `, + values + ); + + const order = orderResult.rows[0]; + await insertDomainEvent(client, { + tenantId: payload.tenantId, + aggregateType: 'order', + aggregateId: order.id, + eventType: 'ORDER_UPDATED', + actorUserId: actor.uid, + payload: { + updatedFields: Object.keys(payload).filter((key) => !['orderId', 'tenantId'].includes(key)), + }, + }); + + return { + orderId: order.id, + orderNumber: order.order_number, + status: order.status, + updatedAt: order.updated_at, + }; + }); +} + +export async function cancelOrder(actor, payload) { + return withTransaction(async (client) => { + await ensureActorUser(client, actor); + const order = await requireOrder(client, payload.tenantId, payload.orderId); + + if (order.status === 'CANCELLED') { + return { + orderId: order.id, + orderNumber: order.order_number, + status: order.status, + alreadyCancelled: true, + }; + } + + const blockingAssignments = await client.query( + ` + SELECT a.id + FROM assignments a + JOIN shifts s ON s.id = a.shift_id + WHERE s.order_id = $1 + AND a.status IN ('CHECKED_IN', 'CHECKED_OUT', 'COMPLETED') + LIMIT 1 + `, + [order.id] + ); + + if (blockingAssignments.rowCount > 0) { + throw new AppError('ORDER_CANCEL_BLOCKED', 'Order has active or completed assignments and cannot be cancelled', 409, { + orderId: order.id, + }); + } + + await client.query( + ` + UPDATE orders + SET status = 'CANCELLED', + notes = CASE + WHEN $2::text IS NULL THEN notes + WHEN notes IS NULL OR notes = '' THEN $2::text + ELSE CONCAT(notes, E'\\n', $2::text) + END, + metadata = COALESCE(metadata, '{}'::jsonb) || $3::jsonb, + updated_at = NOW() + WHERE id = $1 + `, + [order.id, payload.reason || null, JSON.stringify(payload.metadata || {})] + ); + + const affectedShiftIds = await client.query( + ` + SELECT id + FROM shifts + WHERE order_id = $1 + `, + [order.id] + ); + + await client.query( + ` + UPDATE shifts + SET status = CASE + WHEN status = 'COMPLETED' THEN status + ELSE 'CANCELLED' + END, + updated_at = NOW() + WHERE order_id = $1 + `, + [order.id] + ); + + await client.query( + ` + UPDATE assignments + SET status = 'CANCELLED', + updated_at = NOW() + WHERE shift_id IN (SELECT id FROM shifts WHERE order_id = $1) + AND status = ANY($2::text[]) + `, + [order.id, CANCELLABLE_ASSIGNMENT_STATUSES] + ); + + await client.query( + ` + UPDATE applications + SET status = 'CANCELLED', + updated_at = NOW() + WHERE shift_id IN (SELECT id FROM shifts WHERE order_id = $1) + AND status = ANY($2::text[]) + `, + [order.id, CANCELLABLE_APPLICATION_STATUSES] + ); + + for (const row of affectedShiftIds.rows) { + const roleIds = await client.query( + 'SELECT id FROM shift_roles WHERE shift_id = $1', + [row.id] + ); + for (const role of roleIds.rows) { + await refreshShiftRoleCounts(client, role.id); + } + await refreshShiftCounts(client, row.id); + } + + await insertDomainEvent(client, { + tenantId: payload.tenantId, + aggregateType: 'order', + aggregateId: order.id, + eventType: 'ORDER_CANCELLED', + actorUserId: actor.uid, + payload: { + reason: payload.reason || null, + }, + }); + + return { + orderId: order.id, + orderNumber: order.order_number, + status: 'CANCELLED', + cancelledShiftCount: affectedShiftIds.rowCount, + }; + }); +} + +export async function changeShiftStatus(actor, payload) { + return withTransaction(async (client) => { + await ensureActorUser(client, actor); + const shift = await requireShift(client, payload.tenantId, payload.shiftId); + + if (payload.status === 'COMPLETED') { + const openSession = await client.query( + ` + SELECT id + FROM attendance_sessions + WHERE assignment_id IN (SELECT id FROM assignments WHERE shift_id = $1) + AND status = 'OPEN' + LIMIT 1 + `, + [shift.id] + ); + if (openSession.rowCount > 0) { + throw new AppError('SHIFT_COMPLETE_BLOCKED', 'Shift has open attendance sessions', 409, { + shiftId: shift.id, + }); + } + } + + const nextStatus = await transitionShiftStatus(client, shift.id, shift.status, payload.status); + + if (nextStatus === 'CANCELLED') { + await client.query( + ` + UPDATE assignments + SET status = 'CANCELLED', + updated_at = NOW() + WHERE shift_id = $1 + AND status = ANY($2::text[]) + `, + [shift.id, CANCELLABLE_ASSIGNMENT_STATUSES] + ); + await client.query( + ` + UPDATE applications + SET status = 'CANCELLED', + updated_at = NOW() + WHERE shift_id = $1 + AND status = ANY($2::text[]) + `, + [shift.id, CANCELLABLE_APPLICATION_STATUSES] + ); + } + + if (nextStatus === 'COMPLETED') { + await client.query( + ` + UPDATE assignments + SET status = 'COMPLETED', + updated_at = NOW() + WHERE shift_id = $1 + AND status IN ('CHECKED_OUT', 'ACCEPTED') + `, + [shift.id] + ); + } + + const roleIds = await client.query('SELECT id FROM shift_roles WHERE shift_id = $1', [shift.id]); + for (const role of roleIds.rows) { + await refreshShiftRoleCounts(client, role.id); + } + await refreshShiftCounts(client, shift.id); + + await insertDomainEvent(client, { + tenantId: payload.tenantId, + aggregateType: 'shift', + aggregateId: shift.id, + eventType: 'SHIFT_STATUS_CHANGED', + actorUserId: actor.uid, + payload: { + fromStatus: shift.status, + toStatus: nextStatus, + reason: payload.reason || null, + metadata: payload.metadata || {}, + }, + }); + + return { + shiftId: shift.id, + orderId: shift.order_id, + status: nextStatus, + }; + }); +} + +export async function assignStaffToShift(actor, payload) { + return withTransaction(async (client) => { + await ensureActorUser(client, actor); + const shift = await requireShift(client, payload.tenantId, payload.shiftId); + const shiftRole = await requireShiftRole(client, payload.shiftRoleId); + + if (shiftRole.shift_id !== shift.id) { + throw new AppError('VALIDATION_ERROR', 'shiftId does not match shiftRoleId', 400, { + shiftId: payload.shiftId, + shiftRoleId: payload.shiftRoleId, + }); + } + + const workforce = await requireWorkforce(client, payload.tenantId, payload.workforceId); + let application = null; + if (payload.applicationId) { + application = await requireApplication(client, payload.tenantId, payload.applicationId); + if (application.shift_id !== shift.id || application.shift_role_id !== shiftRole.id || application.staff_id !== workforce.staff_id) { + throw new AppError('VALIDATION_ERROR', 'applicationId does not match shift role and workforce staff', 400, { + applicationId: payload.applicationId, + }); + } + } + + const existingAssignment = await findAssignmentForShiftRoleWorkforce(client, shiftRole.id, workforce.id); + if (existingAssignment && existingAssignment.status !== 'CANCELLED') { + return { + assignmentId: existingAssignment.id, + shiftId: shift.id, + shiftRoleId: shiftRole.id, + status: existingAssignment.status, + existing: true, + }; + } + + if (shiftRole.assigned_count >= shiftRole.workers_needed) { + throw new AppError('SHIFT_ROLE_FILLED', 'Shift role is already filled', 409, { + shiftRoleId: shiftRole.id, + }); + } + + const assignmentResult = await client.query( + ` + INSERT INTO assignments ( + tenant_id, + business_id, + vendor_id, + shift_id, + shift_role_id, + workforce_id, + staff_id, + application_id, + status, + assigned_at, + metadata + ) + VALUES ($1, $2, $3, $4, $5, $6, $7, $8, 'ASSIGNED', NOW(), $9::jsonb) + RETURNING id, status + `, + [ + shift.tenant_id, + shift.business_id, + shift.vendor_id, + shift.id, + shiftRole.id, + workforce.id, + workforce.staff_id, + application?.id || null, + JSON.stringify(payload.metadata || {}), + ] + ); + + if (application) { + await client.query( + ` + UPDATE applications + SET status = 'CONFIRMED', + updated_at = NOW() + WHERE id = $1 + `, + [application.id] + ); + } + + await refreshShiftRoleCounts(client, shiftRole.id); + await refreshShiftCounts(client, shift.id); + + if (['OPEN', 'PENDING_CONFIRMATION'].includes(shift.status)) { + await transitionShiftStatus(client, shift.id, shift.status, 'ASSIGNED'); + } + + const assignment = assignmentResult.rows[0]; + await insertDomainEvent(client, { + tenantId: payload.tenantId, + aggregateType: 'assignment', + aggregateId: assignment.id, + eventType: 'STAFF_ASSIGNED', + actorUserId: actor.uid, + payload: { + shiftId: shift.id, + shiftRoleId: shiftRole.id, + workforceId: workforce.id, + applicationId: application?.id || null, + }, + }); + + return { + assignmentId: assignment.id, + shiftId: shift.id, + shiftRoleId: shiftRole.id, + status: assignment.status, + existing: false, + }; + }); +} + +function buildAttendanceValidation(assignment, payload) { + const expectedPoint = { + latitude: assignment.expected_latitude, + longitude: assignment.expected_longitude, + }; + const actualPoint = { + latitude: payload.latitude, + longitude: payload.longitude, + }; + const distance = distanceMeters(actualPoint, expectedPoint); + const expectedNfcTag = assignment.expected_nfc_tag_uid; + const radius = assignment.geofence_radius_meters; + + let validationStatus = 'ACCEPTED'; + let validationReason = null; + + if (expectedNfcTag && payload.sourceType === 'NFC' && payload.nfcTagUid !== expectedNfcTag) { + validationStatus = 'REJECTED'; + validationReason = 'NFC tag mismatch'; + } + + if ( + validationStatus === 'ACCEPTED' + && distance != null + && radius != null + && distance > radius + ) { + validationStatus = 'REJECTED'; + validationReason = `Outside geofence by ${distance - radius} meters`; + } + + return { + distance, + validationStatus, + validationReason, + withinGeofence: distance == null || radius == null ? null : distance <= radius, + }; +} + +async function createAttendanceEvent(actor, payload, eventType) { + return withTransaction(async (client) => { + await ensureActorUser(client, actor); + const assignment = await requireAssignment(client, payload.assignmentId); + const validation = buildAttendanceValidation(assignment, payload); + const capturedAt = toIsoOrNull(payload.capturedAt) || new Date().toISOString(); + + if (validation.validationStatus === 'REJECTED') { + const rejectedEvent = await client.query( + ` + INSERT INTO attendance_events ( + tenant_id, + assignment_id, + shift_id, + staff_id, + clock_point_id, + event_type, + source_type, + source_reference, + nfc_tag_uid, + device_id, + latitude, + longitude, + accuracy_meters, + distance_to_clock_point_meters, + within_geofence, + validation_status, + validation_reason, + captured_at, + raw_payload + ) + VALUES ( + $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, 'REJECTED', $16, $17, $18::jsonb + ) + RETURNING id + `, + [ + assignment.tenant_id, + assignment.id, + assignment.shift_id, + assignment.staff_id, + assignment.clock_point_id, + eventType, + payload.sourceType, + payload.sourceReference || null, + payload.nfcTagUid || null, + payload.deviceId || null, + payload.latitude ?? null, + payload.longitude ?? null, + payload.accuracyMeters ?? null, + validation.distance, + validation.withinGeofence, + validation.validationReason, + capturedAt, + JSON.stringify(payload.rawPayload || {}), + ] + ); + + await insertDomainEvent(client, { + tenantId: assignment.tenant_id, + aggregateType: 'attendance_event', + aggregateId: rejectedEvent.rows[0].id, + eventType: `${eventType}_REJECTED`, + actorUserId: actor.uid, + payload: { + assignmentId: assignment.id, + sourceType: payload.sourceType, + validationReason: validation.validationReason, + }, + }); + + throw new AppError('ATTENDANCE_VALIDATION_FAILED', validation.validationReason, 409, { + assignmentId: payload.assignmentId, + attendanceEventId: rejectedEvent.rows[0].id, + distanceToClockPointMeters: validation.distance, + }); + } + + const sessionResult = await client.query( + ` + SELECT id, status + FROM attendance_sessions + WHERE assignment_id = $1 + `, + [assignment.id] + ); + + if (eventType === 'CLOCK_IN' && sessionResult.rowCount > 0 && sessionResult.rows[0].status === 'OPEN') { + throw new AppError('ATTENDANCE_ALREADY_OPEN', 'Assignment already has an open attendance session', 409, { + assignmentId: assignment.id, + }); + } + + if (eventType === 'CLOCK_OUT' && sessionResult.rowCount === 0) { + throw new AppError('ATTENDANCE_NOT_OPEN', 'Assignment does not have an open attendance session', 409, { + assignmentId: assignment.id, + }); + } + + const eventResult = await client.query( + ` + INSERT INTO attendance_events ( + tenant_id, + assignment_id, + shift_id, + staff_id, + clock_point_id, + event_type, + source_type, + source_reference, + nfc_tag_uid, + device_id, + latitude, + longitude, + accuracy_meters, + distance_to_clock_point_meters, + within_geofence, + validation_status, + validation_reason, + captured_at, + raw_payload + ) + VALUES ( + $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19::jsonb + ) + RETURNING id, validation_status + `, + [ + assignment.tenant_id, + assignment.id, + assignment.shift_id, + assignment.staff_id, + assignment.clock_point_id, + eventType, + payload.sourceType, + payload.sourceReference || null, + payload.nfcTagUid || null, + payload.deviceId || null, + payload.latitude ?? null, + payload.longitude ?? null, + payload.accuracyMeters ?? null, + validation.distance, + validation.withinGeofence, + validation.validationStatus, + validation.validationReason, + capturedAt, + JSON.stringify(payload.rawPayload || {}), + ] + ); + + let sessionId; + if (eventType === 'CLOCK_IN') { + const insertedSession = await client.query( + ` + INSERT INTO attendance_sessions ( + tenant_id, + assignment_id, + staff_id, + clock_in_event_id, + status, + check_in_at + ) + VALUES ($1, $2, $3, $4, 'OPEN', $5) + RETURNING id + `, + [assignment.tenant_id, assignment.id, assignment.staff_id, eventResult.rows[0].id, capturedAt] + ); + sessionId = insertedSession.rows[0].id; + await client.query( + ` + UPDATE assignments + SET status = 'CHECKED_IN', + checked_in_at = $2, + updated_at = NOW() + WHERE id = $1 + `, + [assignment.id, capturedAt] + ); + } else { + const existingSession = sessionResult.rows[0]; + await client.query( + ` + UPDATE attendance_sessions + SET clock_out_event_id = $2, + status = 'CLOSED', + check_out_at = $3, + worked_minutes = GREATEST(EXTRACT(EPOCH FROM ($3 - check_in_at))::INTEGER / 60, 0), + updated_at = NOW() + WHERE id = $1 + `, + [existingSession.id, eventResult.rows[0].id, capturedAt] + ); + sessionId = existingSession.id; + await client.query( + ` + UPDATE assignments + SET status = 'CHECKED_OUT', + checked_out_at = $2, + updated_at = NOW() + WHERE id = $1 + `, + [assignment.id, capturedAt] + ); + } + + await insertDomainEvent(client, { + tenantId: assignment.tenant_id, + aggregateType: 'attendance_event', + aggregateId: eventResult.rows[0].id, + eventType, + actorUserId: actor.uid, + payload: { + assignmentId: assignment.id, + sessionId, + sourceType: payload.sourceType, + }, + }); + + return { + attendanceEventId: eventResult.rows[0].id, + assignmentId: assignment.id, + sessionId, + status: eventType, + validationStatus: eventResult.rows[0].validation_status, + }; + }); +} + +export async function clockIn(actor, payload) { + return createAttendanceEvent(actor, payload, 'CLOCK_IN'); +} + +export async function clockOut(actor, payload) { + return createAttendanceEvent(actor, payload, 'CLOCK_OUT'); +} + +export async function addFavoriteStaff(actor, payload) { + return withTransaction(async (client) => { + await ensureActorUser(client, actor); + await requireBusiness(client, payload.tenantId, payload.businessId); + + const staffResult = await client.query( + ` + SELECT id + FROM staffs + WHERE id = $1 AND tenant_id = $2 + `, + [payload.staffId, payload.tenantId] + ); + if (staffResult.rowCount === 0) { + throw new AppError('NOT_FOUND', 'Staff not found in tenant scope', 404, { + staffId: payload.staffId, + }); + } + + const favoriteResult = await client.query( + ` + INSERT INTO staff_favorites ( + tenant_id, + business_id, + staff_id, + created_by_user_id + ) + VALUES ($1, $2, $3, $4) + ON CONFLICT (business_id, staff_id) DO UPDATE + SET created_by_user_id = EXCLUDED.created_by_user_id + RETURNING id + `, + [payload.tenantId, payload.businessId, payload.staffId, actor.uid] + ); + + await insertDomainEvent(client, { + tenantId: payload.tenantId, + aggregateType: 'staff_favorite', + aggregateId: favoriteResult.rows[0].id, + eventType: 'STAFF_FAVORITED', + actorUserId: actor.uid, + payload, + }); + + return { + favoriteId: favoriteResult.rows[0].id, + businessId: payload.businessId, + staffId: payload.staffId, + }; + }); +} + +export async function removeFavoriteStaff(actor, payload) { + return withTransaction(async (client) => { + await ensureActorUser(client, actor); + const deleted = await client.query( + ` + DELETE FROM staff_favorites + WHERE tenant_id = $1 + AND business_id = $2 + AND staff_id = $3 + RETURNING id + `, + [payload.tenantId, payload.businessId, payload.staffId] + ); + + if (deleted.rowCount === 0) { + throw new AppError('NOT_FOUND', 'Favorite staff record not found', 404, payload); + } + + await insertDomainEvent(client, { + tenantId: payload.tenantId, + aggregateType: 'staff_favorite', + aggregateId: deleted.rows[0].id, + eventType: 'STAFF_UNFAVORITED', + actorUserId: actor.uid, + payload, + }); + + return { + removed: true, + businessId: payload.businessId, + staffId: payload.staffId, + }; + }); +} + +export async function createStaffReview(actor, payload) { + return withTransaction(async (client) => { + await ensureActorUser(client, actor); + const assignment = await requireAssignment(client, payload.assignmentId); + if (assignment.business_id !== payload.businessId || assignment.staff_id !== payload.staffId) { + throw new AppError('VALIDATION_ERROR', 'Assignment does not match business/staff review target', 400, { + assignmentId: payload.assignmentId, + businessId: payload.businessId, + staffId: payload.staffId, + }); + } + + const reviewResult = await client.query( + ` + INSERT INTO staff_reviews ( + tenant_id, + business_id, + staff_id, + assignment_id, + reviewer_user_id, + rating, + review_text, + tags + ) + VALUES ($1, $2, $3, $4, $5, $6, $7, $8::jsonb) + ON CONFLICT (business_id, assignment_id, staff_id) DO UPDATE + SET reviewer_user_id = EXCLUDED.reviewer_user_id, + rating = EXCLUDED.rating, + review_text = EXCLUDED.review_text, + tags = EXCLUDED.tags, + updated_at = NOW() + RETURNING id, rating + `, + [ + payload.tenantId, + payload.businessId, + payload.staffId, + payload.assignmentId, + actor.uid, + payload.rating, + payload.reviewText || null, + JSON.stringify(payload.tags || []), + ] + ); + + await client.query( + ` + UPDATE staffs + SET average_rating = review_stats.avg_rating, + rating_count = review_stats.rating_count, + updated_at = NOW() + FROM ( + SELECT staff_id, + ROUND(AVG(rating)::numeric, 2) AS avg_rating, + COUNT(*)::INTEGER AS rating_count + FROM staff_reviews + WHERE staff_id = $1 + GROUP BY staff_id + ) review_stats + WHERE staffs.id = review_stats.staff_id + `, + [payload.staffId] + ); + + await insertDomainEvent(client, { + tenantId: payload.tenantId, + aggregateType: 'staff_review', + aggregateId: reviewResult.rows[0].id, + eventType: 'STAFF_REVIEW_CREATED', + actorUserId: actor.uid, + payload: { + staffId: payload.staffId, + assignmentId: payload.assignmentId, + rating: payload.rating, + }, + }); + + return { + reviewId: reviewResult.rows[0].id, + assignmentId: payload.assignmentId, + staffId: payload.staffId, + rating: reviewResult.rows[0].rating, + }; + }); +} diff --git a/backend/command-api/src/services/db.js b/backend/command-api/src/services/db.js new file mode 100644 index 00000000..5499a01e --- /dev/null +++ b/backend/command-api/src/services/db.js @@ -0,0 +1,94 @@ +import { Pool } from 'pg'; + +let pool; + +function parseIntOrDefault(value, fallback) { + const parsed = Number.parseInt(`${value || fallback}`, 10); + return Number.isFinite(parsed) ? parsed : fallback; +} + +export function resolveDatabasePoolConfig({ + preferIdempotency = false, + maxEnvVar = 'DB_POOL_MAX', +} = {}) { + const primaryUrl = preferIdempotency + ? process.env.IDEMPOTENCY_DATABASE_URL || process.env.DATABASE_URL + : process.env.DATABASE_URL || process.env.IDEMPOTENCY_DATABASE_URL; + + if (primaryUrl) { + return { + connectionString: primaryUrl, + max: parseIntOrDefault(process.env[maxEnvVar], 10), + idleTimeoutMillis: parseIntOrDefault(process.env.DB_IDLE_TIMEOUT_MS, 30000), + }; + } + + const user = process.env.DB_USER; + const password = process.env.DB_PASSWORD; + const database = process.env.DB_NAME; + const host = process.env.DB_HOST || ( + process.env.INSTANCE_CONNECTION_NAME + ? `/cloudsql/${process.env.INSTANCE_CONNECTION_NAME}` + : '' + ); + + if (!user || password == null || !database || !host) { + return null; + } + + return { + host, + port: parseIntOrDefault(process.env.DB_PORT, 5432), + user, + password, + database, + max: parseIntOrDefault(process.env[maxEnvVar], 10), + idleTimeoutMillis: parseIntOrDefault(process.env.DB_IDLE_TIMEOUT_MS, 30000), + }; +} + +export function isDatabaseConfigured() { + return Boolean(resolveDatabasePoolConfig()); +} + +function getPool() { + if (!pool) { + const resolved = resolveDatabasePoolConfig(); + if (!resolved) { + throw new Error('Database connection settings are required'); + } + pool = new Pool(resolved); + } + return pool; +} + +export async function query(text, params = []) { + return getPool().query(text, params); +} + +export async function withTransaction(work) { + const client = await getPool().connect(); + try { + await client.query('BEGIN'); + const result = await work(client); + await client.query('COMMIT'); + return result; + } catch (error) { + await client.query('ROLLBACK'); + throw error; + } finally { + client.release(); + } +} + +export async function checkDatabaseHealth() { + const result = await query('SELECT 1 AS ok'); + return result.rows[0]?.ok === 1; +} + +export async function closePool() { + if (pool) { + await pool.end(); + pool = null; + } +} diff --git a/backend/command-api/src/services/idempotency-store.js b/backend/command-api/src/services/idempotency-store.js index 8a3df3d4..5c34d76c 100644 --- a/backend/command-api/src/services/idempotency-store.js +++ b/backend/command-api/src/services/idempotency-store.js @@ -1,4 +1,5 @@ import { Pool } from 'pg'; +import { resolveDatabasePoolConfig } from './db.js'; const DEFAULT_TTL_SECONDS = Number.parseInt(process.env.IDEMPOTENCY_TTL_SECONDS || '86400', 10); const CLEANUP_EVERY_OPS = Number.parseInt(process.env.IDEMPOTENCY_CLEANUP_EVERY_OPS || '100', 10); @@ -12,9 +13,9 @@ function shouldUseSqlStore() { return false; } if (mode === 'sql') { - return true; + return Boolean(resolveDatabasePoolConfig({ preferIdempotency: true, maxEnvVar: 'IDEMPOTENCY_DB_POOL_MAX' })); } - return Boolean(process.env.IDEMPOTENCY_DATABASE_URL); + return Boolean(resolveDatabasePoolConfig({ preferIdempotency: true, maxEnvVar: 'IDEMPOTENCY_DB_POOL_MAX' })); } function gcExpiredMemoryRecords(now = Date.now()) { @@ -55,15 +56,16 @@ function createMemoryAdapter() { } async function createSqlAdapter() { - const connectionString = process.env.IDEMPOTENCY_DATABASE_URL; - if (!connectionString) { - throw new Error('IDEMPOTENCY_DATABASE_URL is required for sql idempotency store'); + const poolConfig = resolveDatabasePoolConfig({ + preferIdempotency: true, + maxEnvVar: 'IDEMPOTENCY_DB_POOL_MAX', + }); + + if (!poolConfig) { + throw new Error('Database connection settings are required for sql idempotency store'); } - const pool = new Pool({ - connectionString, - max: Number.parseInt(process.env.IDEMPOTENCY_DB_POOL_MAX || '5', 10), - }); + const pool = new Pool(poolConfig); await pool.query(` CREATE TABLE IF NOT EXISTS command_idempotency ( diff --git a/backend/command-api/test/app.test.js b/backend/command-api/test/app.test.js index bce88d82..ad1a91c3 100644 --- a/backend/command-api/test/app.test.js +++ b/backend/command-api/test/app.test.js @@ -6,9 +6,42 @@ import { __resetIdempotencyStoreForTests } from '../src/services/idempotency-sto process.env.AUTH_BYPASS = 'true'; +const tenantId = '11111111-1111-4111-8111-111111111111'; +const businessId = '22222222-2222-4222-8222-222222222222'; +const shiftId = '33333333-3333-4333-8333-333333333333'; + +function validOrderCreatePayload() { + return { + tenantId, + businessId, + orderNumber: 'ORD-1001', + title: 'Cafe Event Staffing', + serviceType: 'EVENT', + shifts: [ + { + shiftCode: 'SHIFT-1', + title: 'Morning Shift', + startsAt: '2026-03-11T08:00:00.000Z', + endsAt: '2026-03-11T16:00:00.000Z', + requiredWorkers: 2, + roles: [ + { + roleCode: 'BARISTA', + roleName: 'Barista', + workersNeeded: 2, + payRateCents: 2200, + billRateCents: 3500, + }, + ], + }, + ], + }; +} + beforeEach(() => { process.env.IDEMPOTENCY_STORE = 'memory'; delete process.env.IDEMPOTENCY_DATABASE_URL; + delete process.env.DATABASE_URL; __resetIdempotencyStoreForTests(); }); @@ -21,34 +54,65 @@ test('GET /healthz returns healthy response', async () => { assert.equal(typeof res.body.requestId, 'string'); }); +test('GET /readyz reports database not configured when no database env is present', async () => { + const app = createApp(); + const res = await request(app).get('/readyz'); + + assert.equal(res.status, 503); + assert.equal(res.body.ok, false); + assert.equal(res.body.status, 'DATABASE_NOT_CONFIGURED'); +}); + test('command route requires idempotency key', async () => { const app = createApp(); const res = await request(app) .post('/commands/orders/create') .set('Authorization', 'Bearer test-token') - .send({ payload: {} }); + .send(validOrderCreatePayload()); assert.equal(res.status, 400); assert.equal(res.body.code, 'MISSING_IDEMPOTENCY_KEY'); }); -test('command route is idempotent by key', async () => { - const app = createApp(); +test('command route is idempotent by key and only executes handler once', async () => { + let callCount = 0; + const app = createApp({ + commandHandlers: { + createOrder: async () => { + callCount += 1; + return { + orderId: '44444444-4444-4444-8444-444444444444', + orderNumber: 'ORD-1001', + status: 'OPEN', + shiftCount: 1, + shiftIds: [shiftId], + }; + }, + acceptShift: async () => assert.fail('acceptShift should not be called'), + clockIn: async () => assert.fail('clockIn should not be called'), + clockOut: async () => assert.fail('clockOut should not be called'), + addFavoriteStaff: async () => assert.fail('addFavoriteStaff should not be called'), + removeFavoriteStaff: async () => assert.fail('removeFavoriteStaff should not be called'), + createStaffReview: async () => assert.fail('createStaffReview should not be called'), + }, + }); const first = await request(app) .post('/commands/orders/create') .set('Authorization', 'Bearer test-token') .set('Idempotency-Key', 'abc-123') - .send({ payload: { order: 'x' } }); + .send(validOrderCreatePayload()); const second = await request(app) .post('/commands/orders/create') .set('Authorization', 'Bearer test-token') .set('Idempotency-Key', 'abc-123') - .send({ payload: { order: 'x' } }); + .send(validOrderCreatePayload()); assert.equal(first.status, 200); assert.equal(second.status, 200); - assert.equal(first.body.commandId, second.body.commandId); + assert.equal(callCount, 1); + assert.equal(first.body.orderId, second.body.orderId); assert.equal(first.body.idempotencyKey, 'abc-123'); + assert.equal(second.body.idempotencyKey, 'abc-123'); }); diff --git a/backend/query-api/package-lock.json b/backend/query-api/package-lock.json index c74c9764..59e60898 100644 --- a/backend/query-api/package-lock.json +++ b/backend/query-api/package-lock.json @@ -10,6 +10,7 @@ "dependencies": { "express": "^4.21.2", "firebase-admin": "^13.0.2", + "pg": "^8.20.0", "pino": "^9.6.0", "pino-http": "^10.3.0" }, @@ -1991,6 +1992,95 @@ "integrity": "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==", "license": "MIT" }, + "node_modules/pg": { + "version": "8.20.0", + "resolved": "https://registry.npmjs.org/pg/-/pg-8.20.0.tgz", + "integrity": "sha512-ldhMxz2r8fl/6QkXnBD3CR9/xg694oT6DZQ2s6c/RI28OjtSOpxnPrUCGOBJ46RCUxcWdx3p6kw/xnDHjKvaRA==", + "license": "MIT", + "dependencies": { + "pg-connection-string": "^2.12.0", + "pg-pool": "^3.13.0", + "pg-protocol": "^1.13.0", + "pg-types": "2.2.0", + "pgpass": "1.0.5" + }, + "engines": { + "node": ">= 16.0.0" + }, + "optionalDependencies": { + "pg-cloudflare": "^1.3.0" + }, + "peerDependencies": { + "pg-native": ">=3.0.1" + }, + "peerDependenciesMeta": { + "pg-native": { + "optional": true + } + } + }, + "node_modules/pg-cloudflare": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/pg-cloudflare/-/pg-cloudflare-1.3.0.tgz", + "integrity": "sha512-6lswVVSztmHiRtD6I8hw4qP/nDm1EJbKMRhf3HCYaqud7frGysPv7FYJ5noZQdhQtN2xJnimfMtvQq21pdbzyQ==", + "license": "MIT", + "optional": true + }, + "node_modules/pg-connection-string": { + "version": "2.12.0", + "resolved": "https://registry.npmjs.org/pg-connection-string/-/pg-connection-string-2.12.0.tgz", + "integrity": "sha512-U7qg+bpswf3Cs5xLzRqbXbQl85ng0mfSV/J0nnA31MCLgvEaAo7CIhmeyrmJpOr7o+zm0rXK+hNnT5l9RHkCkQ==", + "license": "MIT" + }, + "node_modules/pg-int8": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/pg-int8/-/pg-int8-1.0.1.tgz", + "integrity": "sha512-WCtabS6t3c8SkpDBUlb1kjOs7l66xsGdKpIPZsg4wR+B3+u9UAum2odSsF9tnvxg80h4ZxLWMy4pRjOsFIqQpw==", + "license": "ISC", + "engines": { + "node": ">=4.0.0" + } + }, + "node_modules/pg-pool": { + "version": "3.13.0", + "resolved": "https://registry.npmjs.org/pg-pool/-/pg-pool-3.13.0.tgz", + "integrity": "sha512-gB+R+Xud1gLFuRD/QgOIgGOBE2KCQPaPwkzBBGC9oG69pHTkhQeIuejVIk3/cnDyX39av2AxomQiyPT13WKHQA==", + "license": "MIT", + "peerDependencies": { + "pg": ">=8.0" + } + }, + "node_modules/pg-protocol": { + "version": "1.13.0", + "resolved": "https://registry.npmjs.org/pg-protocol/-/pg-protocol-1.13.0.tgz", + "integrity": "sha512-zzdvXfS6v89r6v7OcFCHfHlyG/wvry1ALxZo4LqgUoy7W9xhBDMaqOuMiF3qEV45VqsN6rdlcehHrfDtlCPc8w==", + "license": "MIT" + }, + "node_modules/pg-types": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/pg-types/-/pg-types-2.2.0.tgz", + "integrity": "sha512-qTAAlrEsl8s4OiEQY69wDvcMIdQN6wdz5ojQiOy6YRMuynxenON0O5oCpJI6lshc6scgAY8qvJ2On/p+CXY0GA==", + "license": "MIT", + "dependencies": { + "pg-int8": "1.0.1", + "postgres-array": "~2.0.0", + "postgres-bytea": "~1.0.0", + "postgres-date": "~1.0.4", + "postgres-interval": "^1.1.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/pgpass": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/pgpass/-/pgpass-1.0.5.tgz", + "integrity": "sha512-FdW9r/jQZhSeohs1Z3sI1yxFQNFvMcnmfuj4WBMUTxOrAyLMaTcE1aAMBiTlbMNaXvBCQuVi0R7hd8udDSP7ug==", + "license": "MIT", + "dependencies": { + "split2": "^4.1.0" + } + }, "node_modules/pino": { "version": "9.14.0", "resolved": "https://registry.npmjs.org/pino/-/pino-9.14.0.tgz", @@ -2040,6 +2130,45 @@ "integrity": "sha512-BndPH67/JxGExRgiX1dX0w1FvZck5Wa4aal9198SrRhZjH3GxKQUKIBnYJTdj2HDN3UQAS06HlfcSbQj2OHmaw==", "license": "MIT" }, + "node_modules/postgres-array": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/postgres-array/-/postgres-array-2.0.0.tgz", + "integrity": "sha512-VpZrUqU5A69eQyW2c5CA1jtLecCsN2U/bD6VilrFDWq5+5UIEVO7nazS3TEcHf1zuPYO/sqGvUvW62g86RXZuA==", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/postgres-bytea": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/postgres-bytea/-/postgres-bytea-1.0.1.tgz", + "integrity": "sha512-5+5HqXnsZPE65IJZSMkZtURARZelel2oXUEO8rH83VS/hxH5vv1uHquPg5wZs8yMAfdv971IU+kcPUczi7NVBQ==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/postgres-date": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/postgres-date/-/postgres-date-1.0.7.tgz", + "integrity": "sha512-suDmjLVQg78nMK2UZ454hAG+OAW+HQPZ6n++TNDUX+L0+uUlLywnoxJKDou51Zm+zTCjrCl0Nq6J9C5hP9vK/Q==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/postgres-interval": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/postgres-interval/-/postgres-interval-1.2.0.tgz", + "integrity": "sha512-9ZhXKM/rw350N1ovuWHbGxnGh/SNJ4cnxHiM0rxE4VN41wsg8P8zWn9hv/buK00RP4WvlOyr/RBDiptyxVbkZQ==", + "license": "MIT", + "dependencies": { + "xtend": "^4.0.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, "node_modules/process-warning": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/process-warning/-/process-warning-5.0.0.tgz", @@ -2839,6 +2968,15 @@ "devOptional": true, "license": "ISC" }, + "node_modules/xtend": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz", + "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==", + "license": "MIT", + "engines": { + "node": ">=0.4" + } + }, "node_modules/y18n": { "version": "5.0.8", "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", diff --git a/backend/query-api/package.json b/backend/query-api/package.json index 4c30b282..33e16830 100644 --- a/backend/query-api/package.json +++ b/backend/query-api/package.json @@ -13,6 +13,7 @@ "dependencies": { "express": "^4.21.2", "firebase-admin": "^13.0.2", + "pg": "^8.20.0", "pino": "^9.6.0", "pino-http": "^10.3.0" }, diff --git a/backend/query-api/src/app.js b/backend/query-api/src/app.js index 41573544..4e883cb3 100644 --- a/backend/query-api/src/app.js +++ b/backend/query-api/src/app.js @@ -4,10 +4,11 @@ import pinoHttp from 'pino-http'; import { requestContext } from './middleware/request-context.js'; import { errorHandler, notFoundHandler } from './middleware/error-handler.js'; import { healthRouter } from './routes/health.js'; +import { createQueryRouter } from './routes/query.js'; const logger = pino({ level: process.env.LOG_LEVEL || 'info' }); -export function createApp() { +export function createApp(options = {}) { const app = express(); app.use(requestContext); @@ -20,6 +21,7 @@ export function createApp() { app.use(express.json({ limit: '2mb' })); app.use(healthRouter); + app.use('/query', createQueryRouter(options.queryService)); app.use(notFoundHandler); app.use(errorHandler); diff --git a/backend/query-api/src/middleware/auth.js b/backend/query-api/src/middleware/auth.js new file mode 100644 index 00000000..9c62c86d --- /dev/null +++ b/backend/query-api/src/middleware/auth.js @@ -0,0 +1,45 @@ +import { AppError } from '../lib/errors.js'; +import { can } from '../services/policy.js'; +import { verifyFirebaseToken } from '../services/firebase-auth.js'; + +function getBearerToken(header) { + if (!header) return null; + const [scheme, token] = header.split(' '); + if (!scheme || scheme.toLowerCase() !== 'bearer' || !token) return null; + return token; +} + +export async function requireAuth(req, _res, next) { + try { + const token = getBearerToken(req.get('Authorization')); + if (!token) { + throw new AppError('UNAUTHENTICATED', 'Missing bearer token', 401); + } + + if (process.env.AUTH_BYPASS === 'true') { + req.actor = { uid: 'test-user', email: 'test@krow.local', role: 'TEST' }; + return next(); + } + + const decoded = await verifyFirebaseToken(token); + req.actor = { + uid: decoded.uid, + email: decoded.email || null, + role: decoded.role || null, + }; + + return next(); + } catch (error) { + if (error instanceof AppError) return next(error); + return next(new AppError('UNAUTHENTICATED', 'Token verification failed', 401)); + } +} + +export function requirePolicy(action, resource) { + return (req, _res, next) => { + if (!can(action, resource, req.actor)) { + return next(new AppError('FORBIDDEN', 'Not allowed to perform this action', 403)); + } + return next(); + }; +} diff --git a/backend/query-api/src/routes/health.js b/backend/query-api/src/routes/health.js index 142dbf78..fed2a5fe 100644 --- a/backend/query-api/src/routes/health.js +++ b/backend/query-api/src/routes/health.js @@ -1,4 +1,5 @@ import { Router } from 'express'; +import { checkDatabaseHealth, isDatabaseConfigured } from '../services/db.js'; export const healthRouter = Router(); @@ -13,3 +14,32 @@ function healthHandler(req, res) { healthRouter.get('/health', healthHandler); healthRouter.get('/healthz', healthHandler); + +healthRouter.get('/readyz', async (req, res) => { + if (!isDatabaseConfigured()) { + return res.status(503).json({ + ok: false, + service: 'krow-query-api', + status: 'DATABASE_NOT_CONFIGURED', + requestId: req.requestId, + }); + } + + try { + const ok = await checkDatabaseHealth(); + return res.status(ok ? 200 : 503).json({ + ok, + service: 'krow-query-api', + status: ok ? 'READY' : 'DATABASE_UNAVAILABLE', + requestId: req.requestId, + }); + } catch (error) { + return res.status(503).json({ + ok: false, + service: 'krow-query-api', + status: 'DATABASE_UNAVAILABLE', + details: { message: error.message }, + requestId: req.requestId, + }); + } +}); diff --git a/backend/query-api/src/routes/query.js b/backend/query-api/src/routes/query.js new file mode 100644 index 00000000..5fe33090 --- /dev/null +++ b/backend/query-api/src/routes/query.js @@ -0,0 +1,138 @@ +import { Router } from 'express'; +import { AppError } from '../lib/errors.js'; +import { requireAuth, requirePolicy } from '../middleware/auth.js'; +import { + getAssignmentAttendance, + getOrderDetail, + getStaffReviewSummary, + listFavoriteStaff, + listOrders, +} from '../services/query-service.js'; + +const defaultQueryService = { + getAssignmentAttendance, + getOrderDetail, + getStaffReviewSummary, + listFavoriteStaff, + listOrders, +}; + +function requireUuid(value, field) { + if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value)) { + throw new AppError('VALIDATION_ERROR', `${field} must be a UUID`, 400, { field }); + } + return value; +} + +export function createQueryRouter(queryService = defaultQueryService) { + const router = Router(); + + router.get( + '/tenants/:tenantId/orders', + requireAuth, + requirePolicy('orders.read', 'order'), + async (req, res, next) => { + try { + const tenantId = requireUuid(req.params.tenantId, 'tenantId'); + const orders = await queryService.listOrders({ + tenantId, + businessId: req.query.businessId, + status: req.query.status, + limit: req.query.limit, + offset: req.query.offset, + }); + return res.status(200).json({ + items: orders, + requestId: req.requestId, + }); + } catch (error) { + return next(error); + } + } + ); + + router.get( + '/tenants/:tenantId/orders/:orderId', + requireAuth, + requirePolicy('orders.read', 'order'), + async (req, res, next) => { + try { + const order = await queryService.getOrderDetail({ + tenantId: requireUuid(req.params.tenantId, 'tenantId'), + orderId: requireUuid(req.params.orderId, 'orderId'), + }); + return res.status(200).json({ + ...order, + requestId: req.requestId, + }); + } catch (error) { + return next(error); + } + } + ); + + router.get( + '/tenants/:tenantId/businesses/:businessId/favorite-staff', + requireAuth, + requirePolicy('business.favorite-staff.read', 'staff'), + async (req, res, next) => { + try { + const items = await queryService.listFavoriteStaff({ + tenantId: requireUuid(req.params.tenantId, 'tenantId'), + businessId: requireUuid(req.params.businessId, 'businessId'), + limit: req.query.limit, + offset: req.query.offset, + }); + return res.status(200).json({ + items, + requestId: req.requestId, + }); + } catch (error) { + return next(error); + } + } + ); + + router.get( + '/tenants/:tenantId/staff/:staffId/review-summary', + requireAuth, + requirePolicy('staff.reviews.read', 'staff'), + async (req, res, next) => { + try { + const summary = await queryService.getStaffReviewSummary({ + tenantId: requireUuid(req.params.tenantId, 'tenantId'), + staffId: requireUuid(req.params.staffId, 'staffId'), + limit: req.query.limit, + }); + return res.status(200).json({ + ...summary, + requestId: req.requestId, + }); + } catch (error) { + return next(error); + } + } + ); + + router.get( + '/tenants/:tenantId/assignments/:assignmentId/attendance', + requireAuth, + requirePolicy('attendance.read', 'attendance'), + async (req, res, next) => { + try { + const attendance = await queryService.getAssignmentAttendance({ + tenantId: requireUuid(req.params.tenantId, 'tenantId'), + assignmentId: requireUuid(req.params.assignmentId, 'assignmentId'), + }); + return res.status(200).json({ + ...attendance, + requestId: req.requestId, + }); + } catch (error) { + return next(error); + } + } + ); + + return router; +} diff --git a/backend/query-api/src/services/db.js b/backend/query-api/src/services/db.js new file mode 100644 index 00000000..272d0e3b --- /dev/null +++ b/backend/query-api/src/services/db.js @@ -0,0 +1,72 @@ +import { Pool } from 'pg'; + +let pool; + +function parseIntOrDefault(value, fallback) { + const parsed = Number.parseInt(`${value || fallback}`, 10); + return Number.isFinite(parsed) ? parsed : fallback; +} + +function resolveDatabasePoolConfig() { + if (process.env.DATABASE_URL) { + return { + connectionString: process.env.DATABASE_URL, + max: parseIntOrDefault(process.env.DB_POOL_MAX, 10), + idleTimeoutMillis: parseIntOrDefault(process.env.DB_IDLE_TIMEOUT_MS, 30000), + }; + } + + const user = process.env.DB_USER; + const password = process.env.DB_PASSWORD; + const database = process.env.DB_NAME; + const host = process.env.DB_HOST || ( + process.env.INSTANCE_CONNECTION_NAME + ? `/cloudsql/${process.env.INSTANCE_CONNECTION_NAME}` + : '' + ); + + if (!user || password == null || !database || !host) { + return null; + } + + return { + host, + port: parseIntOrDefault(process.env.DB_PORT, 5432), + user, + password, + database, + max: parseIntOrDefault(process.env.DB_POOL_MAX, 10), + idleTimeoutMillis: parseIntOrDefault(process.env.DB_IDLE_TIMEOUT_MS, 30000), + }; +} + +export function isDatabaseConfigured() { + return Boolean(resolveDatabasePoolConfig()); +} + +function getPool() { + if (!pool) { + const resolved = resolveDatabasePoolConfig(); + if (!resolved) { + throw new Error('Database connection settings are required'); + } + pool = new Pool(resolved); + } + return pool; +} + +export async function query(text, params = []) { + return getPool().query(text, params); +} + +export async function checkDatabaseHealth() { + const result = await query('SELECT 1 AS ok'); + return result.rows[0]?.ok === 1; +} + +export async function closePool() { + if (pool) { + await pool.end(); + pool = null; + } +} diff --git a/backend/query-api/src/services/firebase-auth.js b/backend/query-api/src/services/firebase-auth.js new file mode 100644 index 00000000..e268d5db --- /dev/null +++ b/backend/query-api/src/services/firebase-auth.js @@ -0,0 +1,13 @@ +import { applicationDefault, getApps, initializeApp } from 'firebase-admin/app'; +import { getAuth } from 'firebase-admin/auth'; + +function ensureAdminApp() { + if (getApps().length === 0) { + initializeApp({ credential: applicationDefault() }); + } +} + +export async function verifyFirebaseToken(token) { + ensureAdminApp(); + return getAuth().verifyIdToken(token); +} diff --git a/backend/query-api/src/services/policy.js b/backend/query-api/src/services/policy.js new file mode 100644 index 00000000..44e7e371 --- /dev/null +++ b/backend/query-api/src/services/policy.js @@ -0,0 +1,5 @@ +export function can(action, resource, actor) { + void action; + void resource; + return Boolean(actor?.uid); +} diff --git a/backend/query-api/src/services/query-service.js b/backend/query-api/src/services/query-service.js new file mode 100644 index 00000000..02a5e795 --- /dev/null +++ b/backend/query-api/src/services/query-service.js @@ -0,0 +1,285 @@ +import { AppError } from '../lib/errors.js'; +import { query } from './db.js'; + +function parseLimit(value, fallback = 20, max = 100) { + const parsed = Number.parseInt(`${value || fallback}`, 10); + if (!Number.isFinite(parsed) || parsed <= 0) return fallback; + return Math.min(parsed, max); +} + +function parseOffset(value) { + const parsed = Number.parseInt(`${value || 0}`, 10); + if (!Number.isFinite(parsed) || parsed < 0) return 0; + return parsed; +} + +export async function listOrders({ tenantId, businessId, status, limit, offset }) { + const result = await query( + ` + SELECT + o.id, + o.order_number AS "orderNumber", + o.title, + o.status, + o.service_type AS "serviceType", + o.starts_at AS "startsAt", + o.ends_at AS "endsAt", + o.location_name AS "locationName", + o.location_address AS "locationAddress", + o.created_at AS "createdAt", + b.id AS "businessId", + b.business_name AS "businessName", + v.id AS "vendorId", + v.company_name AS "vendorName", + COALESCE(COUNT(s.id), 0)::INTEGER AS "shiftCount", + COALESCE(SUM(s.required_workers), 0)::INTEGER AS "requiredWorkers", + COALESCE(SUM(s.assigned_workers), 0)::INTEGER AS "assignedWorkers" + FROM orders o + JOIN businesses b ON b.id = o.business_id + LEFT JOIN vendors v ON v.id = o.vendor_id + LEFT JOIN shifts s ON s.order_id = o.id + WHERE o.tenant_id = $1 + AND ($2::uuid IS NULL OR o.business_id = $2::uuid) + AND ($3::text IS NULL OR o.status = $3::text) + GROUP BY o.id, b.id, v.id + ORDER BY o.created_at DESC + LIMIT $4 OFFSET $5 + `, + [ + tenantId, + businessId || null, + status || null, + parseLimit(limit), + parseOffset(offset), + ] + ); + + return result.rows; +} + +export async function getOrderDetail({ tenantId, orderId }) { + const orderResult = await query( + ` + SELECT + o.id, + o.order_number AS "orderNumber", + o.title, + o.description, + o.status, + o.service_type AS "serviceType", + o.starts_at AS "startsAt", + o.ends_at AS "endsAt", + o.location_name AS "locationName", + o.location_address AS "locationAddress", + o.latitude, + o.longitude, + o.notes, + o.created_at AS "createdAt", + b.id AS "businessId", + b.business_name AS "businessName", + v.id AS "vendorId", + v.company_name AS "vendorName" + FROM orders o + JOIN businesses b ON b.id = o.business_id + LEFT JOIN vendors v ON v.id = o.vendor_id + WHERE o.tenant_id = $1 + AND o.id = $2 + `, + [tenantId, orderId] + ); + + if (orderResult.rowCount === 0) { + throw new AppError('NOT_FOUND', 'Order not found', 404, { tenantId, orderId }); + } + + const shiftsResult = await query( + ` + SELECT + s.id, + s.shift_code AS "shiftCode", + s.title, + s.status, + s.starts_at AS "startsAt", + s.ends_at AS "endsAt", + s.timezone, + s.location_name AS "locationName", + s.location_address AS "locationAddress", + s.required_workers AS "requiredWorkers", + s.assigned_workers AS "assignedWorkers", + cp.id AS "clockPointId", + cp.label AS "clockPointLabel" + FROM shifts s + LEFT JOIN clock_points cp ON cp.id = s.clock_point_id + WHERE s.tenant_id = $1 + AND s.order_id = $2 + ORDER BY s.starts_at ASC + `, + [tenantId, orderId] + ); + + const shiftIds = shiftsResult.rows.map((row) => row.id); + let rolesByShiftId = new Map(); + + if (shiftIds.length > 0) { + const rolesResult = await query( + ` + SELECT + sr.id, + sr.shift_id AS "shiftId", + sr.role_code AS "roleCode", + sr.role_name AS "roleName", + sr.workers_needed AS "workersNeeded", + sr.assigned_count AS "assignedCount", + sr.pay_rate_cents AS "payRateCents", + sr.bill_rate_cents AS "billRateCents" + FROM shift_roles sr + WHERE sr.shift_id = ANY($1::uuid[]) + ORDER BY sr.role_name ASC + `, + [shiftIds] + ); + rolesByShiftId = rolesResult.rows.reduce((map, row) => { + const list = map.get(row.shiftId) || []; + list.push(row); + map.set(row.shiftId, list); + return map; + }, new Map()); + } + + return { + ...orderResult.rows[0], + shifts: shiftsResult.rows.map((shift) => ({ + ...shift, + roles: rolesByShiftId.get(shift.id) || [], + })), + }; +} + +export async function listFavoriteStaff({ tenantId, businessId, limit, offset }) { + const result = await query( + ` + SELECT + sf.id AS "favoriteId", + sf.created_at AS "favoritedAt", + s.id AS "staffId", + s.full_name AS "fullName", + s.primary_role AS "primaryRole", + s.average_rating AS "averageRating", + s.rating_count AS "ratingCount", + s.status + FROM staff_favorites sf + JOIN staffs s ON s.id = sf.staff_id + WHERE sf.tenant_id = $1 + AND sf.business_id = $2 + ORDER BY sf.created_at DESC + LIMIT $3 OFFSET $4 + `, + [tenantId, businessId, parseLimit(limit), parseOffset(offset)] + ); + return result.rows; +} + +export async function getStaffReviewSummary({ tenantId, staffId, limit }) { + const staffResult = await query( + ` + SELECT + id AS "staffId", + full_name AS "fullName", + average_rating AS "averageRating", + rating_count AS "ratingCount", + primary_role AS "primaryRole", + status + FROM staffs + WHERE tenant_id = $1 + AND id = $2 + `, + [tenantId, staffId] + ); + + if (staffResult.rowCount === 0) { + throw new AppError('NOT_FOUND', 'Staff not found', 404, { tenantId, staffId }); + } + + const reviewsResult = await query( + ` + SELECT + sr.id AS "reviewId", + sr.rating, + sr.review_text AS "reviewText", + sr.tags, + sr.created_at AS "createdAt", + b.id AS "businessId", + b.business_name AS "businessName", + sr.assignment_id AS "assignmentId" + FROM staff_reviews sr + JOIN businesses b ON b.id = sr.business_id + WHERE sr.tenant_id = $1 + AND sr.staff_id = $2 + ORDER BY sr.created_at DESC + LIMIT $3 + `, + [tenantId, staffId, parseLimit(limit, 10, 50)] + ); + + return { + ...staffResult.rows[0], + reviews: reviewsResult.rows, + }; +} + +export async function getAssignmentAttendance({ tenantId, assignmentId }) { + const assignmentResult = await query( + ` + SELECT + a.id AS "assignmentId", + a.status, + a.shift_id AS "shiftId", + a.staff_id AS "staffId", + s.title AS "shiftTitle", + s.starts_at AS "shiftStartsAt", + s.ends_at AS "shiftEndsAt", + attendance_sessions.id AS "sessionId", + attendance_sessions.status AS "sessionStatus", + attendance_sessions.check_in_at AS "checkInAt", + attendance_sessions.check_out_at AS "checkOutAt", + attendance_sessions.worked_minutes AS "workedMinutes" + FROM assignments a + JOIN shifts s ON s.id = a.shift_id + LEFT JOIN attendance_sessions ON attendance_sessions.assignment_id = a.id + WHERE a.id = $1 + AND a.tenant_id = $2 + `, + [assignmentId, tenantId] + ); + + if (assignmentResult.rowCount === 0) { + throw new AppError('NOT_FOUND', 'Assignment not found', 404, { tenantId, assignmentId }); + } + + const eventsResult = await query( + ` + SELECT + id AS "attendanceEventId", + event_type AS "eventType", + source_type AS "sourceType", + source_reference AS "sourceReference", + nfc_tag_uid AS "nfcTagUid", + latitude, + longitude, + distance_to_clock_point_meters AS "distanceToClockPointMeters", + within_geofence AS "withinGeofence", + validation_status AS "validationStatus", + validation_reason AS "validationReason", + captured_at AS "capturedAt" + FROM attendance_events + WHERE assignment_id = $1 + ORDER BY captured_at ASC + `, + [assignmentId] + ); + + return { + ...assignmentResult.rows[0], + events: eventsResult.rows, + }; +} diff --git a/backend/query-api/test/app.test.js b/backend/query-api/test/app.test.js index d2274ba5..f2a5e9d7 100644 --- a/backend/query-api/test/app.test.js +++ b/backend/query-api/test/app.test.js @@ -3,6 +3,14 @@ import assert from 'node:assert/strict'; import request from 'supertest'; import { createApp } from '../src/app.js'; +process.env.AUTH_BYPASS = 'true'; + +const tenantId = '11111111-1111-4111-8111-111111111111'; +const orderId = '22222222-2222-4222-8222-222222222222'; +const businessId = '33333333-3333-4333-8333-333333333333'; +const staffId = '44444444-4444-4444-8444-444444444444'; +const assignmentId = '55555555-5555-4555-8555-555555555555'; + test('GET /healthz returns healthy response', async () => { const app = createApp(); const res = await request(app).get('/healthz'); @@ -14,6 +22,21 @@ test('GET /healthz returns healthy response', async () => { assert.equal(typeof res.headers['x-request-id'], 'string'); }); +test('GET /readyz reports database not configured when no database env is present', async () => { + delete process.env.DATABASE_URL; + delete process.env.DB_HOST; + delete process.env.DB_NAME; + delete process.env.DB_USER; + delete process.env.DB_PASSWORD; + delete process.env.INSTANCE_CONNECTION_NAME; + + const app = createApp(); + const res = await request(app).get('/readyz'); + + assert.equal(res.status, 503); + assert.equal(res.body.status, 'DATABASE_NOT_CONFIGURED'); +}); + test('GET unknown route returns not found envelope', async () => { const app = createApp(); const res = await request(app).get('/query/unknown'); @@ -22,3 +45,82 @@ test('GET unknown route returns not found envelope', async () => { assert.equal(res.body.code, 'NOT_FOUND'); assert.equal(typeof res.body.requestId, 'string'); }); + +test('GET /query/tenants/:tenantId/orders returns injected query result', async () => { + const app = createApp({ + queryService: { + listOrders: async (params) => { + assert.equal(params.tenantId, tenantId); + return [{ + id: orderId, + orderNumber: 'ORD-1001', + title: 'Cafe Event Staffing', + status: 'OPEN', + }]; + }, + getOrderDetail: async () => assert.fail('getOrderDetail should not be called'), + listFavoriteStaff: async () => assert.fail('listFavoriteStaff should not be called'), + getStaffReviewSummary: async () => assert.fail('getStaffReviewSummary should not be called'), + getAssignmentAttendance: async () => assert.fail('getAssignmentAttendance should not be called'), + }, + }); + + const res = await request(app) + .get(`/query/tenants/${tenantId}/orders`) + .set('Authorization', 'Bearer test-token'); + + assert.equal(res.status, 200); + assert.equal(res.body.items.length, 1); + assert.equal(res.body.items[0].id, orderId); +}); + +test('GET /query/tenants/:tenantId/assignments/:assignmentId/attendance returns injected attendance', async () => { + const app = createApp({ + queryService: { + listOrders: async () => assert.fail('listOrders should not be called'), + getOrderDetail: async () => assert.fail('getOrderDetail should not be called'), + listFavoriteStaff: async () => assert.fail('listFavoriteStaff should not be called'), + getStaffReviewSummary: async () => assert.fail('getStaffReviewSummary should not be called'), + getAssignmentAttendance: async (params) => { + assert.equal(params.tenantId, tenantId); + assert.equal(params.assignmentId, assignmentId); + return { + assignmentId, + sessionStatus: 'OPEN', + events: [], + }; + }, + }, + }); + + const res = await request(app) + .get(`/query/tenants/${tenantId}/assignments/${assignmentId}/attendance`) + .set('Authorization', 'Bearer test-token'); + + assert.equal(res.status, 200); + assert.equal(res.body.assignmentId, assignmentId); + assert.equal(res.body.sessionStatus, 'OPEN'); +}); + +test('GET /query/tenants/:tenantId/businesses/:businessId/favorite-staff validates auth and handler wiring', async () => { + const app = createApp({ + queryService: { + listOrders: async () => assert.fail('listOrders should not be called'), + getOrderDetail: async () => assert.fail('getOrderDetail should not be called'), + listFavoriteStaff: async (params) => { + assert.equal(params.tenantId, tenantId); + assert.equal(params.businessId, businessId); + return [{ staffId, fullName: 'Ana Barista' }]; + }, + getStaffReviewSummary: async () => assert.fail('getStaffReviewSummary should not be called'), + getAssignmentAttendance: async () => assert.fail('getAssignmentAttendance should not be called'), + }, + }); + + const res = await request(app) + .get(`/query/tenants/${tenantId}/businesses/${businessId}/favorite-staff`) + .set('Authorization', 'Bearer test-token'); + + assert.equal(res.status, 200); + assert.equal(res.body.items[0].staffId, staffId); +}); diff --git a/docs/MILESTONES/M4/planning/m4-api-catalog.md b/docs/MILESTONES/M4/planning/m4-api-catalog.md index 516ebf38..b361aee1 100644 --- a/docs/MILESTONES/M4/planning/m4-api-catalog.md +++ b/docs/MILESTONES/M4/planning/m4-api-catalog.md @@ -1,12 +1,13 @@ # M4 API Catalog (Core Only) Status: Active -Date: 2026-02-24 +Date: 2026-03-11 Owner: Technical Lead Environment: dev ## Frontend source of truth Use this file and `docs/MILESTONES/M4/planning/m4-core-api-frontend-guide.md` for core endpoint consumption. +Use `docs/MILESTONES/M4/planning/m4-v2-frontend-migration-guide.md` for actual frontend migration sequencing across v2 services. ## Related next-slice contract Verification pipeline design (attire, government ID, certification): diff --git a/docs/MILESTONES/M4/planning/m4-core-api-frontend-guide.md b/docs/MILESTONES/M4/planning/m4-core-api-frontend-guide.md index ef3e18dd..1a808c04 100644 --- a/docs/MILESTONES/M4/planning/m4-core-api-frontend-guide.md +++ b/docs/MILESTONES/M4/planning/m4-core-api-frontend-guide.md @@ -1,11 +1,20 @@ # M4 Core API Frontend Guide (Dev) Status: Active -Last updated: 2026-02-27 +Last updated: 2026-03-11 Audience: Web and mobile frontend developers +Related guide: +1. `docs/MILESTONES/M4/planning/m4-v2-frontend-migration-guide.md` + +Scope note: +1. This file documents the core API contract only. +2. For service readiness and migration sequencing across `core-api-v2`, `command-api-v2`, and `query-api-v2`, use the v2 frontend migration guide above. + ## 1) Base URLs (dev) -1. Core API: `https://krow-core-api-e3g6witsvq-uc.a.run.app` +1. Core API v2: `https://krow-core-api-v2-e3g6witsvq-uc.a.run.app` +2. Legacy core API: `https://krow-core-api-e3g6witsvq-uc.a.run.app` +3. For new frontend integration on this branch, use the v2 URL. ## 2) Auth requirements 1. Send Firebase ID token on protected routes: @@ -293,7 +302,7 @@ Authorization: Bearer ## 5.1 Signed URL request ```ts const token = await firebaseAuth.currentUser?.getIdToken(); -const res = await fetch('https://krow-core-api-e3g6witsvq-uc.a.run.app/core/create-signed-url', { +const res = await fetch('https://krow-core-api-v2-e3g6witsvq-uc.a.run.app/core/create-signed-url', { method: 'POST', headers: { Authorization: `Bearer ${token}`, @@ -310,7 +319,7 @@ const data = await res.json(); ## 5.2 Model request ```ts const token = await firebaseAuth.currentUser?.getIdToken(); -const res = await fetch('https://krow-core-api-e3g6witsvq-uc.a.run.app/core/invoke-llm', { +const res = await fetch('https://krow-core-api-v2-e3g6witsvq-uc.a.run.app/core/invoke-llm', { method: 'POST', headers: { Authorization: `Bearer ${token}`, @@ -331,7 +340,7 @@ const data = await res.json(); ## 5.3 Rapid audio transcribe request ```ts const token = await firebaseAuth.currentUser?.getIdToken(); -const res = await fetch('https://krow-core-api-e3g6witsvq-uc.a.run.app/core/rapid-orders/transcribe', { +const res = await fetch('https://krow-core-api-v2-e3g6witsvq-uc.a.run.app/core/rapid-orders/transcribe', { method: 'POST', headers: { Authorization: `Bearer ${token}`, @@ -349,7 +358,7 @@ const data = await res.json(); ## 5.4 Rapid text parse request ```ts const token = await firebaseAuth.currentUser?.getIdToken(); -const res = await fetch('https://krow-core-api-e3g6witsvq-uc.a.run.app/core/rapid-orders/parse', { +const res = await fetch('https://krow-core-api-v2-e3g6witsvq-uc.a.run.app/core/rapid-orders/parse', { method: 'POST', headers: { Authorization: `Bearer ${token}`, diff --git a/docs/MILESTONES/M4/planning/m4-target-schema-blueprint.md b/docs/MILESTONES/M4/planning/m4-target-schema-blueprint.md index 2f81014b..31d7a425 100644 --- a/docs/MILESTONES/M4/planning/m4-target-schema-blueprint.md +++ b/docs/MILESTONES/M4/planning/m4-target-schema-blueprint.md @@ -178,11 +178,17 @@ Tables: 3. `workforce` 4. `applications` 5. `assignments` +6. `staff_reviews` +7. `staff_favorites` Rules: 1. One active workforce relation per `(vendor_id, staff_id)`. 2. One application per `(shift_id, role_id, staff_id)` unless versioned intentionally. 3. Assignment state transitions only through command APIs. +4. Business quality signals are relational: + - `staff_reviews` stores rating and review text from businesses, + - `staff_favorites` stores reusable staffing preferences, + - aggregate rating is materialized on `staffs`. ## 4.5 Compliance and Verification Tables: @@ -222,19 +228,22 @@ Rules: ## 4.9 Attendance, Timesheets, and Offense Governance Tables: -1. `attendance_events` (append-only: clock-in/out, source, correction metadata) -2. `attendance_sessions` (derived work session per assignment) -3. `timesheets` (approval-ready payroll snapshot) -4. `timesheet_adjustments` (manual edits with reason and actor) -5. `offense_policies` (tenant/business scoped policy set) -6. `offense_rules` (threshold ladder and consequence) -7. `offense_events` (actual violation events) -8. `enforcement_actions` (warning, suspension, disable, block) +1. `clock_points` (approved tap and geo validation points per business or venue) +2. `attendance_events` (append-only: clock-in/out, source, NFC, geo, correction metadata) +3. `attendance_sessions` (derived work session per assignment) +4. `timesheets` (approval-ready payroll snapshot) +5. `timesheet_adjustments` (manual edits with reason and actor) +6. `offense_policies` (tenant/business scoped policy set) +7. `offense_rules` (threshold ladder and consequence) +8. `offense_events` (actual violation events) +9. `enforcement_actions` (warning, suspension, disable, block) Rules: 1. Attendance corrections are additive events, not destructive overwrites. -2. Offense consequences are computed from policy + history and persisted as explicit actions. -3. Manual overrides require actor, reason, and timestamp in audit trail. +2. NFC and geo validation happens against `clock_points`, not hardcoded client logic. +3. Rejected attendance attempts are still logged as events for audit. +4. Offense consequences are computed from policy + history and persisted as explicit actions. +5. Manual overrides require actor, reason, and timestamp in audit trail. ## 4.10 Stakeholder Network Extensibility Tables: diff --git a/docs/MILESTONES/M4/planning/m4-target-schema-models-and-keys.md b/docs/MILESTONES/M4/planning/m4-target-schema-models-and-keys.md index ebfb3dc8..71ebefee 100644 --- a/docs/MILESTONES/M4/planning/m4-target-schema-models-and-keys.md +++ b/docs/MILESTONES/M4/planning/m4-target-schema-models-and-keys.md @@ -96,6 +96,8 @@ erDiagram | `shift_managers` | `id` | `shift_id -> shifts.id`, `team_member_id -> team_members.id` | `(shift_id, team_member_id)` | | `applications` | `id` | `tenant_id -> tenants.id`, `shift_id -> shifts.id`, `role_id -> roles.id`, `staff_id -> staffs.id` | `(shift_id, role_id, staff_id)` | | `assignments` | `id` | `tenant_id -> tenants.id`, `shift_role_id -> shift_roles.id`, `workforce_id -> workforce.id` | `(shift_role_id, workforce_id)` active | +| `staff_reviews` | `id` | `tenant_id -> tenants.id`, `business_id -> businesses.id`, `staff_id -> staffs.id`, `assignment_id -> assignments.id` | `(business_id, assignment_id, staff_id)` | +| `staff_favorites` | `id` | `tenant_id -> tenants.id`, `business_id -> businesses.id`, `staff_id -> staffs.id` | `(business_id, staff_id)` | ### 4.2 Diagram @@ -122,6 +124,11 @@ erDiagram STAFFS ||--o{ APPLICATIONS : applies SHIFT_ROLES ||--o{ ASSIGNMENTS : allocates WORKFORCE ||--o{ ASSIGNMENTS : executes + BUSINESSES ||--o{ STAFF_REVIEWS : rates + STAFFS ||--o{ STAFF_REVIEWS : receives + ASSIGNMENTS ||--o{ STAFF_REVIEWS : references + BUSINESSES ||--o{ STAFF_FAVORITES : favorites + STAFFS ||--o{ STAFF_FAVORITES : selected ``` ``` @@ -131,7 +138,8 @@ erDiagram | Model | Primary key | Foreign keys | Important unique keys | |---|---|---|---| -| `attendance_events` | `id` | `tenant_id -> tenants.id`, `assignment_id -> assignments.id` | `(assignment_id, source_event_id)` | +| `clock_points` | `id` | `tenant_id -> tenants.id`, `business_id -> businesses.id` | `(tenant_id, nfc_tag_uid)` nullable | +| `attendance_events` | `id` | `tenant_id -> tenants.id`, `assignment_id -> assignments.id`, `clock_point_id -> clock_points.id` | append-only event log | | `attendance_sessions` | `id` | `tenant_id -> tenants.id`, `assignment_id -> assignments.id` | one open session per assignment | | `timesheets` | `id` | `tenant_id -> tenants.id`, `assignment_id -> assignments.id`, `staff_id -> staffs.id` | `(assignment_id)` | | `timesheet_adjustments` | `id` | `timesheet_id -> timesheets.id`, `actor_user_id -> users.id` | - | @@ -144,6 +152,8 @@ erDiagram ```mermaid erDiagram + BUSINESSES ||--o{ CLOCK_POINTS : defines + CLOCK_POINTS ||--o{ ATTENDANCE_EVENTS : validates ASSIGNMENTS ||--o{ ATTENDANCE_EVENTS : emits ASSIGNMENTS ||--o{ ATTENDANCE_SESSIONS : opens ASSIGNMENTS ||--o{ TIMESHEETS : settles diff --git a/docs/MILESTONES/M4/planning/m4-v2-frontend-migration-guide.md b/docs/MILESTONES/M4/planning/m4-v2-frontend-migration-guide.md new file mode 100644 index 00000000..bed3e739 --- /dev/null +++ b/docs/MILESTONES/M4/planning/m4-v2-frontend-migration-guide.md @@ -0,0 +1,303 @@ +# M4 V2 Frontend Migration Guide + +Status: Active +Last updated: 2026-03-11 +Audience: Web and mobile frontend developers + +## 1) Purpose +This document tells frontend exactly how to migrate toward the v2 backend services on this branch. + +It is intentionally strict about readiness: +1. `core-api-v2` is ready for frontend integration now for uploads, signed URLs, model calls, and verification workflows. +2. `command-api-v2` now has a first real write slice backed by the v2 SQL schema and verified through live smoke tests. +3. `query-api-v2` now has a first real read slice backed by the v2 SQL schema and verified through live smoke tests. + +Frontend should not assume all three services are ready just because they are deployed. + +## 2) Live dev service URLs +1. Core API v2: `https://krow-core-api-v2-e3g6witsvq-uc.a.run.app` +2. Command API v2: `https://krow-command-api-v2-e3g6witsvq-uc.a.run.app` +3. Query API v2: `https://krow-query-api-v2-e3g6witsvq-uc.a.run.app` + +## 3) Readiness summary + +| Service | Status | Frontend guidance | +| --- | --- | --- | +| `core-api-v2` | Ready now with persistence caveat | Use for file upload, signed URLs, model calls, rapid order helpers, and verification flows | +| `command-api-v2` | First production slice | Use for documented v2 write flows only | +| `query-api-v2` | First production slice | Use for documented v2 read flows only | + +## 4) Non-negotiable migration rules +1. Do not point undocumented read screens to `query-api-v2` yet. +2. Do not replace undocumented order, shift, or staffing mutations with `command-api-v2` yet. +3. Do move all new service-style frontend work to `core-api-v2`. +4. Do use command/query v2 for the routes listed in this document when building the new v2 clients. +5. Any new frontend abstraction should separate: + - `core service client` + - `command service client` + - `query service client` + - `legacy Data Connect access` +6. Build the frontend with switchable adapters so the command/query cutover is a client config change, not a rewrite. + +## 5) Auth and headers +All protected v2 routes currently require Firebase ID token: + +```http +Authorization: Bearer +``` + +All services return: +1. `X-Request-Id` response header +2. Standard error envelope: + +```json +{ + "code": "STRING_CODE", + "message": "Human readable message", + "details": {}, + "requestId": "uuid" +} +``` + +Additional rule for command routes: + +```http +Idempotency-Key: +``` + +## 6) What frontend can migrate now + +### 6.1 Move to `core-api-v2` now +1. File uploads +2. Signed download URL generation +3. Rapid order voice transcription +4. Rapid order structured parsing +5. Generic model invocation +6. Verification job creation +7. Verification status polling +8. Manual verification review and retry + +### 6.2 Keep on existing stack for now +1. Business reads +2. Staff reads +3. Shift lists and details outside the documented order detail shape +4. Applications lists and details not yet served by query v2 +5. Payments and reporting reads + +### 6.3 Move to command/query v2 now for the new v2 clients +1. Order creation +2. Order update +3. Order cancel +4. Shift assign staff +5. Shift accept +6. Shift status change +7. Attendance clock-in and clock-out +8. Favorite staff add and remove +9. Staff review create +10. Order list +11. Order detail +12. Favorite staff list +13. Staff review summary +14. Assignment attendance detail + +## 7) Core API v2 routes frontend can use today +Use this service for backend capabilities that should not run directly from the client. + +Important caveat: +1. File storage is real and backed by Google Cloud Storage. +2. Verification job state is not yet persisted to the v2 SQL schema. +3. Frontend can integrate with these routes now, but do not treat verification history as mission-critical durable state yet. + +Base URL: + +```text +https://krow-core-api-v2-e3g6witsvq-uc.a.run.app +``` + +Routes: +1. `POST /core/upload-file` +2. `POST /core/create-signed-url` +3. `POST /core/invoke-llm` +4. `POST /core/rapid-orders/transcribe` +5. `POST /core/rapid-orders/parse` +6. `POST /core/verifications` +7. `GET /core/verifications/:verificationId` +8. `POST /core/verifications/:verificationId/review` +9. `POST /core/verifications/:verificationId/retry` +10. `GET /health` + +For request and response examples, use: +1. `docs/MILESTONES/M4/planning/m4-core-api-frontend-guide.md` +2. `docs/MILESTONES/M4/planning/m4-api-catalog.md` + +## 8) Command API v2 routes ready for the first migration slice +These routes are deployed and backed by the v2 SQL schema. They enforce auth, policy gate, and idempotency. + +Base URL: + +```text +https://krow-command-api-v2-e3g6witsvq-uc.a.run.app +``` + +Routes: +1. `POST /commands/orders/create` +2. `POST /commands/orders/:orderId/update` +3. `POST /commands/orders/:orderId/cancel` +4. `POST /commands/shifts/:shiftId/change-status` +5. `POST /commands/shifts/:shiftId/assign-staff` +6. `POST /commands/shifts/:shiftId/accept` +7. `POST /commands/attendance/clock-in` +8. `POST /commands/attendance/clock-out` +9. `POST /commands/businesses/:businessId/favorite-staff` +10. `DELETE /commands/businesses/:businessId/favorite-staff/:staffId` +11. `POST /commands/assignments/:assignmentId/reviews` +12. `GET /health` +13. `GET /readyz` + +Implemented now: +1. `POST /commands/orders/create` +2. `POST /commands/orders/:orderId/update` +3. `POST /commands/orders/:orderId/cancel` +4. `POST /commands/shifts/:shiftId/change-status` +5. `POST /commands/shifts/:shiftId/assign-staff` +6. `POST /commands/shifts/:shiftId/accept` +7. `POST /commands/attendance/clock-in` +8. `POST /commands/attendance/clock-out` +9. `POST /commands/businesses/:businessId/favorite-staff` +10. `DELETE /commands/businesses/:businessId/favorite-staff/:staffId` +11. `POST /commands/assignments/:assignmentId/reviews` + +Live verification completed on 2026-03-11: +1. order create +2. order update +3. order cancel +4. shift assign staff +5. shift accept +6. shift status change +7. attendance clock-in +8. attendance clock-out +9. favorite add +10. favorite list +11. review create +12. review summary +13. order list/detail +14. attendance detail + +Order creation request contract: + +```json +{ + "tenantId": "uuid", + "businessId": "uuid", + "vendorId": "uuid", + "orderNumber": "ORD-1001", + "title": "Cafe Event Staffing", + "serviceType": "EVENT", + "shifts": [ + { + "shiftCode": "SHIFT-1", + "title": "Morning Shift", + "startsAt": "2026-03-11T08:00:00.000Z", + "endsAt": "2026-03-11T16:00:00.000Z", + "requiredWorkers": 2, + "roles": [ + { + "roleCode": "BARISTA", + "roleName": "Barista", + "workersNeeded": 2 + } + ] + } + ] +} +``` + +Order creation success response: + +```json +{ + "orderId": "uuid", + "orderNumber": "ORD-1001", + "status": "OPEN", + "shiftCount": 1, + "shiftIds": ["uuid"], + "idempotencyKey": "abc-123", + "requestId": "uuid" +} +``` + +Important: +1. This is the first real write slice, not the full command surface. +2. Frontend should migrate only the documented routes. +3. Reuse one idempotency key per user action and never retry with a new key unless the UI is creating a brand new action. +4. The old `501` placeholders for order update, order cancel, shift status change, and shift assign staff are now implemented. + +## 9) Query API v2 routes ready for the first migration slice +Base URL: + +```text +https://krow-query-api-v2-e3g6witsvq-uc.a.run.app +``` + +Current routes: +1. `GET /health` +2. `GET /healthz` +3. `GET /readyz` +4. `GET /query/tenants/:tenantId/orders` +5. `GET /query/tenants/:tenantId/orders/:orderId` +6. `GET /query/tenants/:tenantId/businesses/:businessId/favorite-staff` +7. `GET /query/tenants/:tenantId/staff/:staffId/review-summary` +8. `GET /query/tenants/:tenantId/assignments/:assignmentId/attendance` + +Frontend can point the new v2 clients to these routes now. Frontend should not point any undocumented screen, list, detail page, dashboard, or reporting view to `query-api-v2` yet. + +## 10) Recommended frontend adapter shape +Frontend should isolate backend calls behind service adapters instead of calling routes inline in screens. + +Suggested split: +1. `coreApiClient` +2. `commandApiClient` +3. `queryApiClient` +4. `legacyDataConnectClient` + +Suggested cutover plan: +1. Move service-style operations to `coreApiClient` first. +2. Add `commandApiClient` now as the write path for the documented v2 write routes. +3. Add `queryApiClient` now as the read path for the documented v2 read routes. +4. Keep everything else on `legacyDataConnectClient` until the replacement route exists. +5. Expand migration route-by-route instead of big-bang switching whole apps. + +## 11) Frontend implementation checklist +1. Add three environment variables: + - `CORE_API_V2_BASE_URL` + - `COMMAND_API_V2_BASE_URL` + - `QUERY_API_V2_BASE_URL` +2. Add shared auth header injection using Firebase ID token. +3. Add shared response envelope parsing. +4. Add request ID logging in frontend network layer. +5. Add `Idempotency-Key` generation utility for command calls. +6. Build command/query clients behind feature flags or adapter switches. +7. Start integration with `core-api-v2`, `command-api-v2`, and `query-api-v2` for the documented routes only. + +## 12) Frontend do and do not +Do: +1. Treat `core-api-v2` as the real backend entrypoint for uploads, model work, and verification. +2. Treat documented command/query v2 routes as the real backend entrypoint for the first v2 domain slice. +3. Build migration-safe abstractions now. +4. Keep old reads and writes isolated so they can be swapped cleanly later. + +Do not: +1. Hardcode v2 command success as if business action is complete. +2. Point undocumented dashboards or reports to query v2 yet. +3. Remove current Data Connect code until the replacement route actually exists and is verified. + +## 13) Practical migration sequence +1. Replace existing upload helpers with `core-api-v2`. +2. Replace signed URL generation with `core-api-v2`. +3. Point rapid order helpers to `core-api-v2`. +4. Point attire and document verification flows to `core-api-v2`. +5. Introduce command client wrapper with idempotency header support. +6. Point new v2 order creation, shift accept, attendance, favorites, and reviews flows to `command-api-v2`. +7. Point new v2 order list/detail, favorites, review summary, and attendance detail screens to `query-api-v2`. +8. Point new v2 order update, order cancel, shift assign, and shift status flows to `command-api-v2`. +9. Keep payments, reports, and remaining scheduling mutations on the legacy stack until the replacement routes exist. diff --git a/makefiles/backend.mk b/makefiles/backend.mk index de0ab649..f2a1a5dc 100644 --- a/makefiles/backend.mk +++ b/makefiles/backend.mk @@ -49,6 +49,9 @@ BACKEND_V2_QUERY_DIR ?= backend/query-api BACKEND_V2_SQL_INSTANCE ?= krow-sql-v2 BACKEND_V2_SQL_DATABASE ?= krow_v2_db +BACKEND_V2_SQL_APP_USER ?= krow_v2_app +BACKEND_V2_SQL_PASSWORD_SECRET ?= krow-v2-sql-app-password +BACKEND_V2_SQL_CONNECTION_NAME ?= $(GCP_PROJECT_ID):$(BACKEND_REGION):$(BACKEND_V2_SQL_INSTANCE) BACKEND_V2_SQL_TIER ?= $(SQL_TIER) BACKEND_V2_DEV_PUBLIC_BUCKET ?= krow-workforce-dev-v2-public @@ -70,7 +73,7 @@ BACKEND_V2_CORE_IMAGE ?= $(BACKEND_REGION)-docker.pkg.dev/$(GCP_PROJECT_ID)/$(BA BACKEND_V2_COMMAND_IMAGE ?= $(BACKEND_REGION)-docker.pkg.dev/$(GCP_PROJECT_ID)/$(BACKEND_V2_ARTIFACT_REPO)/command-api-v2:latest BACKEND_V2_QUERY_IMAGE ?= $(BACKEND_REGION)-docker.pkg.dev/$(GCP_PROJECT_ID)/$(BACKEND_V2_ARTIFACT_REPO)/query-api-v2:latest -.PHONY: backend-help backend-enable-apis backend-bootstrap-dev backend-migrate-idempotency backend-deploy-core backend-deploy-commands backend-deploy-workers backend-smoke-core backend-smoke-commands backend-logs-core backend-bootstrap-v2-dev backend-deploy-core-v2 backend-deploy-commands-v2 backend-deploy-query-v2 backend-smoke-core-v2 backend-smoke-commands-v2 backend-smoke-query-v2 backend-logs-core-v2 backend-v2-migrate-idempotency +.PHONY: backend-help backend-enable-apis backend-bootstrap-dev backend-migrate-idempotency backend-deploy-core backend-deploy-commands backend-deploy-workers backend-smoke-core backend-smoke-commands backend-logs-core backend-bootstrap-v2-dev backend-deploy-core-v2 backend-deploy-commands-v2 backend-deploy-query-v2 backend-smoke-core-v2 backend-smoke-commands-v2 backend-smoke-query-v2 backend-logs-core-v2 backend-v2-migrate-idempotency backend-v2-migrate-schema backend-help: @echo "--> Backend Foundation Commands" @@ -88,7 +91,8 @@ backend-help: @echo " make backend-bootstrap-v2-dev [ENV=dev] Bootstrap isolated v2 resources and SQL instance" @echo " make backend-deploy-core-v2 [ENV=dev] Build + deploy core API v2 service" @echo " make backend-deploy-commands-v2 [ENV=dev] Build + deploy command API v2 service" - @echo " make backend-deploy-query-v2 [ENV=dev] Build + deploy query API v2 scaffold service" + @echo " make backend-deploy-query-v2 [ENV=dev] Build + deploy query API v2 service" + @echo " make backend-v2-migrate-schema Apply v2 domain schema against krow-sql-v2" @echo " make backend-v2-migrate-idempotency Apply command idempotency migration against v2 DB" @echo " make backend-smoke-core-v2 [ENV=dev] Smoke test core API v2 /health" @echo " make backend-smoke-commands-v2 [ENV=dev] Smoke test command API v2 /health" @@ -309,6 +313,29 @@ backend-bootstrap-v2-dev: backend-enable-apis else \ echo " - Cloud SQL database already exists: $(BACKEND_V2_SQL_DATABASE)"; \ fi + @echo "--> Ensuring v2 SQL application password secret [$(BACKEND_V2_SQL_PASSWORD_SECRET)] exists..." + @if ! gcloud secrets describe $(BACKEND_V2_SQL_PASSWORD_SECRET) --project=$(GCP_PROJECT_ID) >/dev/null 2>&1; then \ + PASSWORD=$$(openssl rand -base64 48 | tr -dc 'A-Za-z0-9' | head -c 32); \ + printf "%s" "$$PASSWORD" | gcloud secrets create $(BACKEND_V2_SQL_PASSWORD_SECRET) \ + --replication-policy=automatic \ + --data-file=- \ + --project=$(GCP_PROJECT_ID); \ + else \ + echo " - Secret already exists: $(BACKEND_V2_SQL_PASSWORD_SECRET)"; \ + fi + @echo "--> Ensuring v2 SQL application user [$(BACKEND_V2_SQL_APP_USER)] exists and matches the current secret..." + @DB_PASSWORD=$$(gcloud secrets versions access latest --secret=$(BACKEND_V2_SQL_PASSWORD_SECRET) --project=$(GCP_PROJECT_ID)); \ + if gcloud sql users list --instance=$(BACKEND_V2_SQL_INSTANCE) --project=$(GCP_PROJECT_ID) --format='value(name)' | grep -qx "$(BACKEND_V2_SQL_APP_USER)"; then \ + gcloud sql users set-password $(BACKEND_V2_SQL_APP_USER) \ + --instance=$(BACKEND_V2_SQL_INSTANCE) \ + --password="$$DB_PASSWORD" \ + --project=$(GCP_PROJECT_ID) >/dev/null; \ + else \ + gcloud sql users create $(BACKEND_V2_SQL_APP_USER) \ + --instance=$(BACKEND_V2_SQL_INSTANCE) \ + --password="$$DB_PASSWORD" \ + --project=$(GCP_PROJECT_ID) >/dev/null; \ + fi @echo "✅ Backend v2 foundation bootstrap complete for [$(ENV)]." backend-deploy-core-v2: @@ -330,16 +357,15 @@ backend-deploy-commands-v2: @test -d $(BACKEND_V2_COMMAND_DIR) || (echo "❌ Missing directory: $(BACKEND_V2_COMMAND_DIR)" && exit 1) @test -f $(BACKEND_V2_COMMAND_DIR)/Dockerfile || (echo "❌ Missing Dockerfile: $(BACKEND_V2_COMMAND_DIR)/Dockerfile" && exit 1) @gcloud builds submit $(BACKEND_V2_COMMAND_DIR) --tag $(BACKEND_V2_COMMAND_IMAGE) --project=$(GCP_PROJECT_ID) - @EXTRA_ENV="APP_ENV=$(ENV),APP_STACK=v2,GCP_PROJECT_ID=$(GCP_PROJECT_ID),PUBLIC_BUCKET=$(BACKEND_V2_PUBLIC_BUCKET),PRIVATE_BUCKET=$(BACKEND_V2_PRIVATE_BUCKET),IDEMPOTENCY_STORE=memory"; \ - if [ -n "$(IDEMPOTENCY_DATABASE_URL)" ]; then \ - EXTRA_ENV="APP_ENV=$(ENV),APP_STACK=v2,GCP_PROJECT_ID=$(GCP_PROJECT_ID),PUBLIC_BUCKET=$(BACKEND_V2_PUBLIC_BUCKET),PRIVATE_BUCKET=$(BACKEND_V2_PRIVATE_BUCKET),IDEMPOTENCY_STORE=sql,IDEMPOTENCY_DATABASE_URL=$(IDEMPOTENCY_DATABASE_URL)"; \ - fi; \ + @EXTRA_ENV="APP_ENV=$(ENV),APP_STACK=v2,GCP_PROJECT_ID=$(GCP_PROJECT_ID),PUBLIC_BUCKET=$(BACKEND_V2_PUBLIC_BUCKET),PRIVATE_BUCKET=$(BACKEND_V2_PRIVATE_BUCKET),IDEMPOTENCY_STORE=sql,INSTANCE_CONNECTION_NAME=$(BACKEND_V2_SQL_CONNECTION_NAME),DB_NAME=$(BACKEND_V2_SQL_DATABASE),DB_USER=$(BACKEND_V2_SQL_APP_USER)"; \ gcloud run deploy $(BACKEND_V2_COMMAND_SERVICE_NAME) \ --image=$(BACKEND_V2_COMMAND_IMAGE) \ --region=$(BACKEND_REGION) \ --project=$(GCP_PROJECT_ID) \ --service-account=$(BACKEND_V2_RUNTIME_SA_EMAIL) \ --set-env-vars=$$EXTRA_ENV \ + --set-secrets=DB_PASSWORD=$(BACKEND_V2_SQL_PASSWORD_SECRET):latest \ + --add-cloudsql-instances=$(BACKEND_V2_SQL_CONNECTION_NAME) \ $(BACKEND_V2_RUN_AUTH_FLAG) @echo "✅ Command backend v2 service deployed." @@ -353,16 +379,24 @@ backend-deploy-query-v2: --region=$(BACKEND_REGION) \ --project=$(GCP_PROJECT_ID) \ --service-account=$(BACKEND_V2_RUNTIME_SA_EMAIL) \ - --set-env-vars=APP_ENV=$(ENV),APP_STACK=v2,GCP_PROJECT_ID=$(GCP_PROJECT_ID) \ + --set-env-vars=APP_ENV=$(ENV),APP_STACK=v2,GCP_PROJECT_ID=$(GCP_PROJECT_ID),INSTANCE_CONNECTION_NAME=$(BACKEND_V2_SQL_CONNECTION_NAME),DB_NAME=$(BACKEND_V2_SQL_DATABASE),DB_USER=$(BACKEND_V2_SQL_APP_USER) \ + --set-secrets=DB_PASSWORD=$(BACKEND_V2_SQL_PASSWORD_SECRET):latest \ + --add-cloudsql-instances=$(BACKEND_V2_SQL_CONNECTION_NAME) \ $(BACKEND_V2_RUN_AUTH_FLAG) @echo "✅ Query backend v2 service deployed." backend-v2-migrate-idempotency: @echo "--> Applying idempotency table migration for command API v2..." - @test -n "$(IDEMPOTENCY_DATABASE_URL)" || (echo "❌ IDEMPOTENCY_DATABASE_URL is required" && exit 1) - @cd $(BACKEND_V2_COMMAND_DIR) && IDEMPOTENCY_DATABASE_URL="$(IDEMPOTENCY_DATABASE_URL)" npm run migrate:idempotency + @test -n "$(IDEMPOTENCY_DATABASE_URL)$(DATABASE_URL)" || (echo "❌ IDEMPOTENCY_DATABASE_URL or DATABASE_URL is required" && exit 1) + @cd $(BACKEND_V2_COMMAND_DIR) && IDEMPOTENCY_DATABASE_URL="$(IDEMPOTENCY_DATABASE_URL)" DATABASE_URL="$(DATABASE_URL)" npm run migrate:idempotency @echo "✅ Idempotency migration applied for command API v2." +backend-v2-migrate-schema: + @echo "--> Applying v2 domain schema migration..." + @test -n "$(DATABASE_URL)" || (echo "❌ DATABASE_URL is required" && exit 1) + @cd $(BACKEND_V2_COMMAND_DIR) && DATABASE_URL="$(DATABASE_URL)" npm run migrate:v2-schema + @echo "✅ V2 domain schema migration applied." + backend-smoke-core-v2: @echo "--> Running core v2 smoke check..." @URL=$$(gcloud run services describe $(BACKEND_V2_CORE_SERVICE_NAME) --region=$(BACKEND_REGION) --project=$(GCP_PROJECT_ID) --format='value(status.url)'); \ @@ -381,7 +415,7 @@ backend-smoke-commands-v2: exit 1; \ fi; \ TOKEN=$$(gcloud auth print-identity-token); \ - curl -fsS -H "Authorization: Bearer $$TOKEN" "$$URL/health" >/dev/null && echo "✅ Command v2 smoke check passed: $$URL/health" + curl -fsS -H "Authorization: Bearer $$TOKEN" "$$URL/readyz" >/dev/null && echo "✅ Command v2 smoke check passed: $$URL/readyz" backend-smoke-query-v2: @echo "--> Running query v2 smoke check..." @@ -391,7 +425,7 @@ backend-smoke-query-v2: exit 1; \ fi; \ TOKEN=$$(gcloud auth print-identity-token); \ - curl -fsS -H "Authorization: Bearer $$TOKEN" "$$URL/health" >/dev/null && echo "✅ Query v2 smoke check passed: $$URL/health" + curl -fsS -H "Authorization: Bearer $$TOKEN" "$$URL/readyz" >/dev/null && echo "✅ Query v2 smoke check passed: $$URL/readyz" backend-logs-core-v2: @echo "--> Reading logs for core backend v2 service [$(BACKEND_V2_CORE_SERVICE_NAME)]..." From 29dc9342e94c4fc01d9a3f9bff0bcad674c1bba3 Mon Sep 17 00:00:00 2001 From: Achintha Isuru Date: Wed, 11 Mar 2026 14:25:35 -0400 Subject: [PATCH 08/21] feat: add mobile design reference to UI/UX guidelines and update .gitignore for paper designer files --- .claude/agents/ui-ux-design.md | 1 + .claude/skills/krow-paper-design/SKILL.md | 232 +++++++++++++++------- .gitignore | 2 + 3 files changed, 166 insertions(+), 69 deletions(-) diff --git a/.claude/agents/ui-ux-design.md b/.claude/agents/ui-ux-design.md index 2128f64a..63398e13 100644 --- a/.claude/agents/ui-ux-design.md +++ b/.claude/agents/ui-ux-design.md @@ -37,6 +37,7 @@ Before any design work, ensure you have loaded: - `krow-mobile-design-system` — Colors, typography, icons, spacing, component patterns - `frontend-design` - `ui-ux-pro-max` +- `mobile-design` Load additional skills as needed for specific design challenges. diff --git a/.claude/skills/krow-paper-design/SKILL.md b/.claude/skills/krow-paper-design/SKILL.md index df9b2994..db585796 100644 --- a/.claude/skills/krow-paper-design/SKILL.md +++ b/.claude/skills/krow-paper-design/SKILL.md @@ -21,19 +21,42 @@ This skill defines the design token system, component patterns, screen structure ### Color Palette +**Primary:** | Token | Hex | Usage | |-------|-----|-------| -| Primary | `#0A39DF` | CTAs, active states, links, selected chips, nav active icons, pay rates | -| Foreground | `#121826` | Headings, primary text, dark UI elements | -| Text Secondary | `#6A7382` | Labels, captions, inactive nav, section headers, placeholder text, back chevrons | -| Secondary BG | `#F1F3F5` | Subtle backgrounds, dividers, map placeholders | -| Border | `#D1D5DB` | Card borders, unselected chip borders, outline button borders | -| Input Border | `#E2E8F0` | Text input borders (lighter than general border) | -| Destructive | `#F04444` | Error states, destructive actions (e.g., Request Swap) | | Background | `#FAFBFC` | Page/artboard background | -| Card BG | `#FFFFFF` | Card surfaces, input backgrounds | -| Success | `#059669` | Active status dot, checkmark icons, requirement met | -| Warning Amber | `#D97706` | Urgent/Pending badge text | +| Foreground | `#121826` | Headings, primary text, dark UI elements | +| Primary | `#0A39DF` | CTAs, active states, links, selected chips, nav active icons, pay rates | +| Primary Fg | `#F7FAFC` | Light foreground on primary surfaces | + +**Semantic:** +| Token | Hex | Usage | +|-------|-----|-------| +| Secondary | `#F1F3F5` | Subtle backgrounds, dividers, secondary button bg | +| Accent | `#F9E547` | Highlight, warning chip accents | +| Text Secondary | `#6A7382` | Labels, captions, inactive nav, section headers, back chevrons | +| Destructive | `#F04444` | Error states, destructive actions | + +**Border & Input:** +| Token | Hex | Usage | +|-------|-----|-------| +| Border | `#D1D5DB` | Card borders, unselected chip borders, outline button borders | +| Input | `#F5F6F8` | Text input background (read-only/disabled states) | + +**Status:** +| Token | Hex | Usage | +|-------|-----|-------| +| Success | `#10B981` | Accept buttons, active status, checkmarks | +| Info | `#0A39DF` | Informational badges (same as Primary) | +| Warning | `#D97706` | Urgent/Pending badge text | +| Neutral | `#94A3B8` | Disabled text, placeholder text | +| Danger | `#F04444` | Error badges, destructive (same as Destructive) | + +**Gradients:** +| Token | Definition | Usage | +|-------|-----------|-------| +| mobileHero | Foreground → Primary → Primary Fg | Hero sections, splash screens | +| adminHero | Primary → Success | Admin/dashboard hero cards | ### Semantic Badge Colors @@ -44,74 +67,121 @@ This skill defines the design token system, component patterns, screen structure | Pending | `#FEF9EE` | `#D97706` | | Urgent | `#FEF9EE` | `#D97706` | | One-Time | `#ECFDF5` | `#059669` | -| Recurring | `#EBF0FF` | `#0A39DF` (use `#EFF6FF` bg on detail pages) | +| Recurring | `#EFF6FF` | `#0A39DF` | ### Typography -| Style | Font | Size | Weight | Line Height | Usage | -|-------|------|------|--------|-------------|-------| -| Display | Inter Tight | 28px | 700 | 34px | Page titles (Find Shifts, My Shifts) | -| H1 | Inter Tight | 24px | 700 | 30px | Detail page titles (venue names) | -| H2 | Inter Tight | 20px | 700 | 26px | Section headings | -| H3 | Inter Tight | 18px | 700 | 22px | Card titles, schedule values | -| Body Large | Manrope | 16px | 600 | 20px | Button text, CTA labels | -| Body Default | Manrope | 14px | 400-500 | 18px | Body text, descriptions | -| Body Small | Manrope | 13px | 400-500 | 16px | Card metadata, time/pay info | -| Caption | Manrope | 12px | 500-600 | 16px | Small chip text, tab labels | -| Section Label | Manrope | 11px | 700 | 14px | Uppercase section headers (letter-spacing: 0.06em) | -| Badge Text | Manrope | 11px | 600-700 | 14px | Status badge labels (letter-spacing: 0.04em) | -| Nav Label | Manrope | 10px | 600 | 12px | Bottom nav labels | +**Inter Tight — Headings:** +| Style | Size | Weight | Letter Spacing | Line Height | Usage | +|-------|------|--------|---------------|-------------|-------| +| Display | 28px | 700 | -0.02em | 34px | Page titles (Find Shifts, My Shifts) | +| Heading 1 | 24px | 700 | -0.02em | 30px | Detail page titles (venue names) | +| Heading 2 | 20px | 700 | -0.01em | 26px | Section headings | +| Heading 3 | 18px | 700 | -0.01em | 22px | Card titles, schedule values | +| Heading 4 | 16px | 700 | — | 20px | Card titles (standard cards), sub-headings | -### Spacing +**Manrope — Body:** +| Style | Size | Weight | Line Height | Usage | +|-------|------|--------|-------------|-------| +| Body Large Regular | 16px | 400 | 20px | Long body text | +| Body Large Medium | 16px | 500 | 20px | Emphasized body text | +| Body Large Semibold | 16px | 600 | 20px | Strong labels, Full Width CTA text (15px) | +| Body Default | 14px | 400 | 18px | Body text, descriptions | +| Body Default Semibold | 14px | 600 | 18px | Button text, chip text, bold body | +| Caption | 12px | 400 | 16px | Small text, helper text, input labels | +| Overline Label | 11px | 600 | 14px | Uppercase section headers (letter-spacing: 0.06em) | +| Badge Text | 11px | 600-700 | 14px | Status badge labels (letter-spacing: 0.04em) | +| Nav Label | 10px | 600 | 12px | Bottom nav labels | + +### Spacing Scale | Token | Value | Usage | |-------|-------|-------| -| Page padding | 24px | Horizontal padding from screen edge | -| Section gap | 16-24px | Between major content sections | -| Group gap | 8-12px | Within a section (e.g., label to input) | -| Element gap | 4px | Tight spacing (e.g., subtitle under title) | -| Bottom safe area | 40px | Padding below last element / CTA | +| xs | 4px | Tight spacing (subtitle under title) | +| sm | 8px | Element gap within groups | +| md | 12px | Group gap (label to input) | +| lg | 16px | Card padding, medium section gap | +| xl | 24px | Page margins, section gap | +| 2xl | 32px | Large section separation | + +**Page Layout:** +| Token | Value | +|-------|-------| +| Page margins | 24px | +| Section gap | 24px | +| Card padding | 16px | +| Element gap | 8-12px | +| Background | `#FAFBFC` | +| Bottom safe area | 40px | ### Border Radii | Token | Value | Usage | |-------|-------|-------| -| sm | 8px | Small chips, badges, status pills, map placeholder | -| md | 12px | Cards, inputs, location cards, contact cards, search fields | -| lg | 14px | Buttons, CTA containers, shift cards (Find Shifts) | -| xl | 24px | Not commonly used | +| sm | 8px | Small chips, badges, status pills | +| md | 12px | Cards, inputs, list row containers, data rows | +| lg | 18px | Hero cards, gradient cards | +| xl | 24px | Large containers | | pill | 999px | Progress bar segments only | +### Icon Sizes + +Standard sizes: 16, 20, 24, 32dp + ## 2. Component Patterns ### Buttons -**Primary CTA:** -- Background: `#0A39DF`, radius: 14px, height: 52px -- Text: Manrope 16px/600, color: `#FFFFFF` -- Padding: 16px vertical, 16px horizontal +All buttons: radius 14px, padding 12px/24px, text Manrope 14px/600 -**Secondary/Outline Button:** -- Background: `#FFFFFF`, border: 1.5px `#D1D5DB`, radius: 14px, height: 52px -- Text: Manrope 16px/600, color: `#121826` +**Primary:** +- Background: `#0A39DF`, text: `#FFFFFF` -**Destructive Outline Button:** -- Background: `#FFFFFF`, border: 1.5px `#F04444`, radius: 14px -- Text: Manrope 14px/600, color: `#F04444` +**Secondary:** +- Background: `#F1F3F5`, border: 1.5px `#D1D5DB`, text: `#121826` + +**Destructive:** +- Background: `#F04444`, text: `#FFFFFF` + +**Disabled:** +- Background: `#F1F3F5`, no border, text: `#94A3B8` + +**Accept:** +- Background: `#10B981`, text: `#FFFFFF` + +**Dark:** +- Background: `#121826`, text: `#FFFFFF` + +**Full Width CTA:** +- Same as Primary but `width: 100%`, padding 14px/24px, text Manrope 15px/600 **Back Icon Button (Bottom CTA):** -- 52x52px square, border: 1.5px `#D1D5DB`, radius: 14px, background: `#FFFFFF` +- 52x52px square, border: 0.5px `#D1D5DB`, radius: 14px, background: `#FFFFFF` - Contains chevron-left SVG (20x20, viewBox 0 0 24 24, stroke `#121826`, strokeWidth 2) - Path: `M15 18L9 12L15 6` ### Chips +All chips: border 1.5px, text Manrope 14px/600, gap 8px for icon+text + **Default (Large) - for role/skill selection:** -- Selected: bg `#EFF6FF`, border 1.5px `#0A39DF`, radius 10px, padding 12px/16px - - Checkmark icon (14x14, stroke `#0A39DF`), text Manrope 14px/600 `#0A39DF` -- Unselected: bg `#FFFFFF`, border 1.5px `#6A7382`, radius 10px, padding 12px/16px +- Selected: bg `#EFF6FF`, border `#0A39DF`, radius 10px, padding 12px/16px + - Checkmark icon (14x14, stroke `#0A39DF`), text `#0A39DF` +- Unselected: bg `#FFFFFF`, border `#6A7382`, radius 10px, padding 12px/16px - Text Manrope 14px/500 `#6A7382` +**Warning Chips:** +- Selected: bg `#F9E5471A`, border `#E6A817`, radius 10px, padding 12px/16px + - Checkmark icon (stroke `#92700C`), text `#92700C` +- Unselected: bg `#FFFFFF`, border `#F0D78C`, radius 10px, padding 12px/16px + - Text `#92700C` + +**Error Chips:** +- Selected: bg `#FEF2F2`, border `#F04444`, radius 10px, padding 12px/16px + - Checkmark icon (stroke `#B91C1C`), text `#B91C1C` +- Unselected: bg `#FFFFFF`, border `#FECACA`, radius 10px, padding 12px/16px + - Text `#B91C1C` + **Small - for tabs, filters:** - Selected: bg `#EFF6FF`, border 1.5px `#0A39DF`, radius 8px, padding 6px/12px - Checkmark icon (12x12), text Manrope 12px/600 `#0A39DF` @@ -119,8 +189,6 @@ This skill defines the design token system, component patterns, screen structure - Text Manrope 12px/500 `#6A7382` - Active (filled): bg `#0A39DF`, radius 8px, padding 6px/12px - Text Manrope 12px/600 `#FFFFFF` -- Dark (filters button): bg `#121826`, radius 8px, padding 6px/12px - - Text Manrope 12px/600 `#FFFFFF`, with leading icon **Status Badges:** - Radius: 8px, padding: 4px/8px @@ -131,39 +199,65 @@ This skill defines the design token system, component patterns, screen structure - Border: 1.5px `#E2E8F0`, radius: 12px, padding: 12px/14px - Background: `#FFFFFF` -- Placeholder: Manrope 14px/400, color `#6A7382` -- Filled: Manrope 14px/500, color `#121826` -- Label above: Manrope 14px/500, color `#121826` +- Placeholder: Manrope 14px/400, color `#94A3B8` +- Filled: Manrope 14px/400, color `#111827` +- Label above: Manrope 12px/500: + - Default/filled: color `#94A3B8` + - Filled with value: color `#6A7382` + - Focused: color `#0A39DF` + - Error: color `#F04444` + - Disabled: color `#94A3B8` - Focused: border color `#0A39DF`, border-width 2px -- Error: border color `#F04444`, helper text `#F04444` +- Error: border color `#F04444`, border-width 2px, background `#FEF2F2` +- Error helper text: Manrope 12px/400, color `#F04444` -### Cards (Shift List Items) +### Border Width -- Background: `#FFFFFF`, border: 1px `#D1D5DB`, radius: 12-14px -- Padding: 16px -- Content: venue name (Manrope 15px/600 `#121826`), subtitle (Manrope 13px/400 `#6A7382`) -- Metadata row: icon (14px, `#6A7382`) + text (Manrope 13px/500 `#6A7382`) -- Pay rate: Inter Tight 18px/700 `#0A39DF` +- **Standard border width: `0.5px`** — All card borders, dividers, and outline buttons use `0.5px` unless explicitly stated otherwise. +- **Text inputs: `1.5px`** — To ensure visibility and distinction from card borders. +- **Chips: `1.5px`** — All chip variants (default, warning, error, small). +- **Secondary buttons: `1.5px`** — Outline/secondary button borders. -### Schedule/Pay Info Cards +### Cards -- Two-column layout with 12px gap -- Background: `#FFFFFF`, border: 1px `#D1D5DB`, radius: 12px, padding: 16px -- Label: Manrope 11px/500-700 uppercase `#6A7382` (letter-spacing 0.05em) -- Value: Inter Tight 18px/700 `#121826` (schedule) or `#121826` (pay) -- Sub-text: Manrope 13px/400 `#6A7382` +**Standard Card:** +- Background: `#FFFFFF`, border: 0.5px `#D1D5DB`, radius: 12px, padding: 16px +- Title: Inter Tight 16px/700 `#121826` +- Body: Manrope 14px/400 `#6A7382` +- Gap: 8px between title and body + +**Hero / Gradient Card:** +- Radius: 18px, padding: 20px, gap: 6px +- Background: gradient (mobileHero or adminHero) +- Label: Manrope 12px/400 `#FFFFFFB3` (white 70%) +- Value: Inter Tight 28px/700 `#FFFFFF` +- Sub-text: Manrope 12px/400 `#FFFFFF99` (white 60%) + +**List Rows (grouped):** +- Container: radius 12px, border 0.5px `#D1D5DB`, background `#FFFFFF`, overflow clip +- Row: padding ~16px, gap between text elements 2px +- Row title: Manrope 14px/600 `#121826` +- Row subtitle: Manrope 13px/400 `#6A7382` +- Row divider: 1px `#D1D5DB` (between rows, not on last) +- Chevron: `›` or SVG, `#6A7382` + +**Data Row:** +- Background: `#F1F3F5`, radius: 12px, padding: 12px +- Label: Manrope 11px/400 `#6A7382` +- Value: Inter Tight 20px/700 `#121826` +- Layout: flex row, equal width columns, gap 8px ### Contact/Info Rows -- Container: radius 12px, border 1px `#D1D5DB`, background `#FFFFFF`, overflow clip -- Row: padding 13px/16px, gap 10px, border-bottom 1px `#F1F3F5` (except last) +- Container: radius 12px, border 0.5px `#D1D5DB`, background `#FFFFFF`, overflow clip +- Row: padding 13px/16px, gap 10px, border-bottom 0.5px `#F1F3F5` (except last) - Icon: 16px, stroke `#6A7382` - Label: Manrope 13px/500 `#6A7382`, width 72px fixed - Value: Manrope 13px/500 `#121826` (or `#0A39DF` for phone/links) ### Section Headers -- Text: Manrope 11px/700, uppercase, letter-spacing 0.06em, color `#6A7382` +- Text: Manrope 11px/600, uppercase, letter-spacing 0.06em, color `#6A7382` - Gap to content below: 10px ## 3. Screen Structure diff --git a/.gitignore b/.gitignore index eb271963..2269f44c 100644 --- a/.gitignore +++ b/.gitignore @@ -194,4 +194,6 @@ apps/mobile/legacy/* AGENTS.md TASKS.md CLAUDE.md +.claude/agents/paper-designer.md +.claude/agent-memory/paper-designer \n# Android Signing (Secure)\n**.jks\n**key.properties From 7e628d0ebfa39262f79ed4520fc85f8713965046 Mon Sep 17 00:00:00 2001 From: Achintha Isuru Date: Wed, 11 Mar 2026 21:22:17 -0400 Subject: [PATCH 09/21] feat: update warning and error chip styles for improved visibility --- .claude/skills/krow-paper-design/SKILL.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/.claude/skills/krow-paper-design/SKILL.md b/.claude/skills/krow-paper-design/SKILL.md index db585796..954c57a0 100644 --- a/.claude/skills/krow-paper-design/SKILL.md +++ b/.claude/skills/krow-paper-design/SKILL.md @@ -172,15 +172,15 @@ All chips: border 1.5px, text Manrope 14px/600, gap 8px for icon+text **Warning Chips:** - Selected: bg `#F9E5471A`, border `#E6A817`, radius 10px, padding 12px/16px - - Checkmark icon (stroke `#92700C`), text `#92700C` + - Checkmark icon (stroke `#E6A817`), text `#E6A817` - Unselected: bg `#FFFFFF`, border `#F0D78C`, radius 10px, padding 12px/16px - - Text `#92700C` + - Text `#E6A817` **Error Chips:** - Selected: bg `#FEF2F2`, border `#F04444`, radius 10px, padding 12px/16px - - Checkmark icon (stroke `#B91C1C`), text `#B91C1C` + - Checkmark icon (stroke `#F04444`), text `#F04444` - Unselected: bg `#FFFFFF`, border `#FECACA`, radius 10px, padding 12px/16px - - Text `#B91C1C` + - Text `#F04444` **Small - for tabs, filters:** - Selected: bg `#EFF6FF`, border 1.5px `#0A39DF`, radius 8px, padding 6px/12px From d814f8052eacfaa23701f584f5e51a97af9442c0 Mon Sep 17 00:00:00 2001 From: Achintha Isuru Date: Wed, 11 Mar 2026 21:23:39 -0400 Subject: [PATCH 10/21] Remove CLAUDE.md from tracking (keep in gitignore) --- CLAUDE.md | 149 ------------------------------------------------------ 1 file changed, 149 deletions(-) delete mode 100644 CLAUDE.md diff --git a/CLAUDE.md b/CLAUDE.md deleted file mode 100644 index 8b17176f..00000000 --- a/CLAUDE.md +++ /dev/null @@ -1,149 +0,0 @@ -# CLAUDE.md - -This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. - -## Project Overview - -KROW Workforce is a workforce management platform monorepo containing Flutter mobile apps, a React web dashboard, and Firebase backend services. - -## Repository Structure - -``` -apps/mobile/ # Flutter monorepo (Melos workspace) - apps/staff/ # Staff mobile app - apps/client/ # Client (business) mobile app - packages/ - design_system/ # Shared UI tokens & components - core/ # Cross-cutting concerns (mixins, extensions) - core_localization/# i18n via Slang - domain/ # Pure Dart entities & failures - data_connect/ # Firebase Data Connect adapter (connectors) - features/staff/ # Staff feature packages - features/client/ # Client feature packages -apps/web/ # React/Vite web dashboard (TypeScript, Tailwind, Redux Toolkit) -backend/ - dataconnect/ # Firebase Data Connect GraphQL schemas - core-api/ # Core business logic service - cloud-functions/ # Serverless functions -``` - -## Common Commands - -All commands use the root `Makefile` (composed from `makefiles/*.mk`). Run `make help` for the full list. - -### Mobile (Flutter) -```bash -make mobile-install # Bootstrap Melos workspace + generate SDK -make mobile-staff-dev-android # Run staff app (add DEVICE=android) -make mobile-client-dev-android # Run client app -make mobile-analyze # Lint (flutter analyze) -make mobile-test # Run tests -make test-e2e # Maestro E2E tests (both apps) -``` - -Single-package operations via Melos: -```bash -cd apps/mobile -melos run gen:l10n # Generate localization (Slang) -melos run gen:build # Run build_runner -melos run analyze:all # Analyze all packages -melos run test:all # Test all packages -``` - -### Web (React/Vite) -```bash -make web-install # npm install -make web-dev # Start dev server -make web-build # Production build -make web-lint # ESLint -make web-test # Vitest -``` - -### Backend (Data Connect) -```bash -make dataconnect-generate-sdk [ENV=dev] # Generate SDK -make dataconnect-deploy [ENV=dev] # Deploy schemas -make dataconnect-sync-full [ENV=dev] # Deploy + migrate + generate -``` - -## Mobile Architecture - -**Clean Architecture** with strict inward dependency flow: - -``` -Presentation (Pages, BLoCs, Widgets) - → Application (Use Cases) - → Domain (Entities, Repository Interfaces, Failures) - ← Data (Repository Implementations, Connectors) -``` - -### Key Patterns - -- **State management:** Flutter BLoC/Cubit. Register BLoCs with `i.add()` (transient), never `i.addSingleton()`. Use `BlocProvider.value()` for shared BLoCs. -- **DI & Routing:** Flutter Modular. Safe navigation via `safeNavigate()`, `safePush()`, `popSafe()`. Never use `Navigator.push()` directly. -- **Error handling in BLoCs:** Use `BlocErrorHandler` mixin with `_safeEmit()` to prevent StateError on disposed BLoCs. -- **Backend access:** All Data Connect calls go through the `data_connect` package's Connectors. Use `_service.run(() => connector.().execute())` for automatic auth/token management. -- **Session management:** `SessionHandlerMixin` + `SessionListener` widget. Initialized in `main.dart` with role-based config. -- **Localization:** All user-facing strings via `context.strings.` from `core_localization`. Error messages via `ErrorTranslator`. -- **Design system:** Use tokens from `UiColors`, `UiTypography`, `UiConstants`. Never hardcode colors, fonts, or spacing. - -### Feature Package Structure - -New features go in `apps/mobile/packages/features///`: -``` -lib/src/ - domain/repositories/ # Abstract interface classes - data/repositories_impl/ # Implementations using data_connect - application/ # Use cases (business logic) - presentation/ - blocs/ # BLoCs/Cubits - pages/ # Pages (prefer StatelessWidget) - widgets/ # Reusable widgets -``` - -### Critical Rules - -- Features must not import other features directly -- Business logic belongs in Use Cases, never in BLoCs or widgets -- Firebase packages (`firebase_auth`, `firebase_data_connect`) belong only in `data_connect` -- Don't add 3rd-party packages without checking `packages/core` first -- Generated code directories are excluded from analysis: `**/dataconnect_generated/**`, `**/*.g.dart`, `**/*.freezed.dart` - -## Code Generation - -- **Slang** (i18n): Input `lib/src/l10n/*.i18n.json` → Output `strings.g.dart` -- **build_runner**: Various generated files (`.g.dart`, `.freezed.dart`) -- **Firebase Data Connect**: Auto-generated SDK in `packages/data_connect/lib/src/dataconnect_generated/` - -## Naming Conventions (Dart) - -| Type | Convention | Example | -|------|-----------|---------| -| Files | `snake_case` | `user_profile_page.dart` | -| Classes | `PascalCase` | `UserProfilePage` | -| Interfaces | suffix `Interface` | `AuthRepositoryInterface` | -| Implementations | suffix `Impl` | `AuthRepositoryImpl` | - -## Key Documentation - -- `docs/MOBILE/00-agent-development-rules.md` — Non-negotiable architecture rules -- `docs/MOBILE/01-architecture-principles.md` — Clean architecture details -- `docs/MOBILE/02-design-system-usage.md` — Design system token usage -- `docs/MOBILE/03-data-connect-connectors-pattern.md` — Backend integration pattern -- `docs/MOBILE/05-release-process.md` — Release quick reference -- `docs/RELEASE/mobile-releases.md` — Complete release guide - -## Skills & Sub-Agents - -#### Skills -- The project has 4 specialized skills in `.claude/skills/` that provide deep domain knowledge. Invoke them and other global skills that you have when working in their domains. - -#### Sub-Agents -- The project has 4 sub-agents in `.claude/sub-agents/` that can be invoked for specific tasks. Invoke them and other global sub-agents that you have when working in their domains. - - -## CI/CD - -- `.github/workflows/mobile-ci.yml` — Mobile build & test on PR -- `.github/workflows/product-release.yml` — Automated versioning, tags, APK builds -- `.github/workflows/web-quality.yml` — Web linting & tests From b61babe3c697039b931dd7a3a39a60876459c20b Mon Sep 17 00:00:00 2001 From: zouantchaw <44246692+zouantchaw@users.noreply.github.com> Date: Thu, 12 Mar 2026 14:09:05 +0100 Subject: [PATCH 11/21] docs(api): consolidate v2 frontend backend guides --- .../API_GUIDES/00-initial-api-contracts.md | 4 + docs/BACKEND/API_GUIDES/README.md | 14 + docs/BACKEND/API_GUIDES/V2/README.md | 120 ++++++ docs/BACKEND/API_GUIDES/V2/command-api.md | 229 +++++++++++ docs/BACKEND/API_GUIDES/V2/core-api.md | 203 +++++++++ docs/BACKEND/API_GUIDES/V2/query-api.md | 151 +++++++ docs/MILESTONES/M4/planning/m4-api-catalog.md | 237 +---------- .../M4/planning/m4-core-api-frontend-guide.md | 385 +----------------- .../m4-v2-frontend-migration-guide.md | 307 +------------- 9 files changed, 740 insertions(+), 910 deletions(-) create mode 100644 docs/BACKEND/API_GUIDES/README.md create mode 100644 docs/BACKEND/API_GUIDES/V2/README.md create mode 100644 docs/BACKEND/API_GUIDES/V2/command-api.md create mode 100644 docs/BACKEND/API_GUIDES/V2/core-api.md create mode 100644 docs/BACKEND/API_GUIDES/V2/query-api.md diff --git a/docs/BACKEND/API_GUIDES/00-initial-api-contracts.md b/docs/BACKEND/API_GUIDES/00-initial-api-contracts.md index b3f860ab..0ef98e5e 100644 --- a/docs/BACKEND/API_GUIDES/00-initial-api-contracts.md +++ b/docs/BACKEND/API_GUIDES/00-initial-api-contracts.md @@ -1,5 +1,9 @@ # KROW Workforce API Contracts +Legacy note: +Use `/Users/wiel/Development/krow-workforce/docs/BACKEND/API_GUIDES/V2/README.md` for the current v2 frontend/backend integration surface. +This document reflects the earlier Data Connect-oriented contract mapping and should not be the source of truth for new v2 client work. + This document captures all API contracts used by the Staff and Client mobile applications. The application backend is powered by **Firebase Data Connect (GraphQL)**, so traditional REST endpoints do not exist natively. For clarity and ease of reading for all engineering team members, the tables below formulate these GraphQL Data Connect queries and mutations into their **Conceptual REST Endpoints** alongside the actual **Data Connect Operation Name**. --- diff --git a/docs/BACKEND/API_GUIDES/README.md b/docs/BACKEND/API_GUIDES/README.md new file mode 100644 index 00000000..15aa7733 --- /dev/null +++ b/docs/BACKEND/API_GUIDES/README.md @@ -0,0 +1,14 @@ +# Backend API Guides + +## Use this for current frontend work + +- [V2 Backend API Guide](./V2/README.md) +- [V2 Core API](./V2/core-api.md) +- [V2 Command API](./V2/command-api.md) +- [V2 Query API](./V2/query-api.md) + +## Legacy reference + +- [Initial API contracts](./00-initial-api-contracts.md) + +The legacy contract doc reflects the older Data Connect-oriented application shape. Do not use it as the source of truth for new v2 frontend work. diff --git a/docs/BACKEND/API_GUIDES/V2/README.md b/docs/BACKEND/API_GUIDES/V2/README.md new file mode 100644 index 00000000..4a5a66c8 --- /dev/null +++ b/docs/BACKEND/API_GUIDES/V2/README.md @@ -0,0 +1,120 @@ +# V2 Backend API Guide + +This is the frontend-facing source of truth for the v2 backend. + +If you are building against the new backend, start here. + +## 1) Which service to use + +| Use case | Service | +| --- | --- | +| File upload, signed URLs, model calls, rapid order helpers, verification flows | `core-api-v2` | +| Business writes and workflow actions | `command-api-v2` | +| Screen reads for the implemented v2 views | `query-api-v2` | + +## 2) Live dev base URLs + +- Core API: `https://krow-core-api-v2-e3g6witsvq-uc.a.run.app` +- Command API: `https://krow-command-api-v2-e3g6witsvq-uc.a.run.app` +- Query API: `https://krow-query-api-v2-e3g6witsvq-uc.a.run.app` + +## 3) Auth and headers + +All protected routes require: + +```http +Authorization: Bearer +``` + +All command routes also require: + +```http +Idempotency-Key: +``` + +All services return the same error envelope: + +```json +{ + "code": "STRING_CODE", + "message": "Human readable message", + "details": {}, + "requestId": "uuid" +} +``` + +## 4) What frontend can use now + +### Ready now + +- `core-api-v2` + - upload file + - create signed URL + - invoke model + - rapid order transcribe + - rapid order parse + - create verification + - get verification + - review verification + - retry verification +- `command-api-v2` + - create order + - update order + - cancel order + - assign staff to shift + - accept shift + - change shift status + - clock in + - clock out + - favorite and unfavorite staff + - create staff review +- `query-api-v2` + - order list + - order detail + - favorite staff list + - staff review summary + - assignment attendance detail + +### Do not move yet + +- reports +- payments and finance screens +- undocumented dashboard reads +- undocumented scheduling reads and writes +- any flow that assumes verification history is durable in SQL + +## 5) Important caveat + +`core-api-v2` is usable now, but verification job state is not yet persisted to `krow-sql-v2`. + +What is durable today: +- uploaded files in Google Cloud Storage +- generated signed URLs +- model invocation itself + +What is not yet durable: +- verification job history +- verification review history +- verification event history + +That means frontend can integrate with verification routes now, but should not treat them as mission-critical durable state yet. + +## 6) Recommended frontend environment variables + +```env +CORE_API_V2_BASE_URL=https://krow-core-api-v2-e3g6witsvq-uc.a.run.app +COMMAND_API_V2_BASE_URL=https://krow-command-api-v2-e3g6witsvq-uc.a.run.app +QUERY_API_V2_BASE_URL=https://krow-query-api-v2-e3g6witsvq-uc.a.run.app +``` + +## 7) Service docs + +- [Core API](./core-api.md) +- [Command API](./command-api.md) +- [Query API](./query-api.md) + +## 8) Frontend integration rule + +Do not point screens directly at database access just because a route does not exist yet. + +If a screen is missing from the docs, the next step is to define the route contract and add it to `query-api-v2` or `command-api-v2`. diff --git a/docs/BACKEND/API_GUIDES/V2/command-api.md b/docs/BACKEND/API_GUIDES/V2/command-api.md new file mode 100644 index 00000000..bbf9d9fd --- /dev/null +++ b/docs/BACKEND/API_GUIDES/V2/command-api.md @@ -0,0 +1,229 @@ +# V2 Command API + +Use `command-api-v2` for write actions that change business state. + +Base URL: + +```text +https://krow-command-api-v2-e3g6witsvq-uc.a.run.app +``` + +## 1) Required headers + +```http +Authorization: Bearer +Idempotency-Key: +Content-Type: application/json +``` + +## 2) Route summary + +| Method | Route | Purpose | +| --- | --- | --- | +| `POST` | `/commands/orders/create` | Create order with shifts and roles | +| `POST` | `/commands/orders/:orderId/update` | Update mutable order fields | +| `POST` | `/commands/orders/:orderId/cancel` | Cancel order and related eligible records | +| `POST` | `/commands/shifts/:shiftId/assign-staff` | Assign workforce to shift role | +| `POST` | `/commands/shifts/:shiftId/accept` | Accept an assigned shift | +| `POST` | `/commands/shifts/:shiftId/change-status` | Move shift to a new valid status | +| `POST` | `/commands/attendance/clock-in` | Record clock-in event | +| `POST` | `/commands/attendance/clock-out` | Record clock-out event | +| `POST` | `/commands/businesses/:businessId/favorite-staff` | Add favorite staff | +| `DELETE` | `/commands/businesses/:businessId/favorite-staff/:staffId` | Remove favorite staff | +| `POST` | `/commands/assignments/:assignmentId/reviews` | Create or update staff review | +| `GET` | `/readyz` | Ready check | + +## 3) Order create + +```text +POST /commands/orders/create +``` + +Request body: + +```json +{ + "tenantId": "uuid", + "businessId": "uuid", + "vendorId": "uuid", + "orderNumber": "ORD-1001", + "title": "Cafe Event Staffing", + "serviceType": "EVENT", + "shifts": [ + { + "shiftCode": "SHIFT-1", + "title": "Morning Shift", + "startsAt": "2026-03-12T08:00:00.000Z", + "endsAt": "2026-03-12T16:00:00.000Z", + "requiredWorkers": 2, + "roles": [ + { + "roleCode": "BARISTA", + "roleName": "Barista", + "workersNeeded": 2 + } + ] + } + ] +} +``` + +## 4) Order update + +```text +POST /commands/orders/:orderId/update +``` + +Required body fields: +- `tenantId` +- at least one mutable field such as `title`, `description`, `vendorId`, `serviceType`, `startsAt`, `endsAt`, `locationName`, `locationAddress`, `latitude`, `longitude`, `notes`, `metadata` + +You can also send `null` to clear nullable fields. + +## 5) Order cancel + +```text +POST /commands/orders/:orderId/cancel +``` + +Example request: + +```json +{ + "tenantId": "uuid", + "reason": "Client cancelled" +} +``` + +## 6) Shift assign staff + +```text +POST /commands/shifts/:shiftId/assign-staff +``` + +Example request: + +```json +{ + "tenantId": "uuid", + "shiftRoleId": "uuid", + "workforceId": "uuid", + "applicationId": "uuid" +} +``` + +## 7) Shift accept + +```text +POST /commands/shifts/:shiftId/accept +``` + +Example request: + +```json +{ + "shiftRoleId": "uuid", + "workforceId": "uuid" +} +``` + +## 8) Shift status change + +```text +POST /commands/shifts/:shiftId/change-status +``` + +Example request: + +```json +{ + "tenantId": "uuid", + "status": "PENDING_CONFIRMATION", + "reason": "Waiting for worker confirmation" +} +``` + +Allowed status values: +- `DRAFT` +- `OPEN` +- `PENDING_CONFIRMATION` +- `ASSIGNED` +- `ACTIVE` +- `COMPLETED` +- `CANCELLED` + +## 9) Attendance + +### Clock in + +```text +POST /commands/attendance/clock-in +``` + +### Clock out + +```text +POST /commands/attendance/clock-out +``` + +Example request body for both: + +```json +{ + "assignmentId": "uuid", + "sourceType": "NFC", + "sourceReference": "iphone-15-pro-max", + "nfcTagUid": "NFC-DEMO-ANA-001", + "deviceId": "device-123", + "latitude": 37.422, + "longitude": -122.084, + "accuracyMeters": 8, + "capturedAt": "2026-03-11T17:15:00.000Z" +} +``` + +## 10) Favorite staff + +### Add favorite + +```text +POST /commands/businesses/:businessId/favorite-staff +``` + +### Remove favorite + +```text +DELETE /commands/businesses/:businessId/favorite-staff/:staffId +``` + +Request body when adding: + +```json +{ + "tenantId": "uuid", + "staffId": "uuid" +} +``` + +## 11) Staff review + +```text +POST /commands/assignments/:assignmentId/reviews +``` + +Example request: + +```json +{ + "tenantId": "uuid", + "businessId": "uuid", + "staffId": "uuid", + "rating": 5, + "reviewText": "Strong shift performance", + "tags": ["punctual", "professional"] +} +``` + +## 12) Live status + +These routes were live-tested on `2026-03-11` against the deployed dev service and `krow-sql-v2`. diff --git a/docs/BACKEND/API_GUIDES/V2/core-api.md b/docs/BACKEND/API_GUIDES/V2/core-api.md new file mode 100644 index 00000000..adc0e3a4 --- /dev/null +++ b/docs/BACKEND/API_GUIDES/V2/core-api.md @@ -0,0 +1,203 @@ +# V2 Core API + +Use `core-api-v2` for backend capabilities that should not live in the client. + +Base URL: + +```text +https://krow-core-api-v2-e3g6witsvq-uc.a.run.app +``` + +## 1) Route summary + +| Method | Route | Purpose | +| --- | --- | --- | +| `POST` | `/core/upload-file` | Upload file to Google Cloud Storage | +| `POST` | `/core/create-signed-url` | Generate a read URL for an uploaded file | +| `POST` | `/core/invoke-llm` | Run a model call | +| `POST` | `/core/rapid-orders/transcribe` | Turn uploaded audio into text | +| `POST` | `/core/rapid-orders/parse` | Turn order text into structured order data | +| `POST` | `/core/verifications` | Create a verification job | +| `GET` | `/core/verifications/:verificationId` | Fetch verification status | +| `POST` | `/core/verifications/:verificationId/review` | Apply manual review decision | +| `POST` | `/core/verifications/:verificationId/retry` | Retry a verification job | +| `GET` | `/health` | Health check | + +## 2) Upload file + +Route: + +```text +POST /core/upload-file +``` + +Send multipart form data: +- `file`: required +- `category`: optional string +- `visibility`: `public` or `private` + +Example response: + +```json +{ + "fileUri": "gs://krow-workforce-dev-private/uploads//file.pdf", + "contentType": "application/pdf", + "size": 12345, + "bucket": "krow-workforce-dev-private", + "path": "uploads//file.pdf", + "requestId": "uuid" +} +``` + +## 3) Create signed URL + +Route: + +```text +POST /core/create-signed-url +``` + +Example request: + +```json +{ + "fileUri": "gs://krow-workforce-dev-private/uploads//file.pdf", + "expiresInSeconds": 300 +} +``` + +Example response: + +```json +{ + "signedUrl": "https://...", + "expiresAt": "2026-03-11T18:30:00.000Z", + "requestId": "uuid" +} +``` + +## 4) Invoke model + +Route: + +```text +POST /core/invoke-llm +``` + +Example request: + +```json +{ + "prompt": "Summarize this staffing request", + "fileUrls": ["gs://krow-workforce-dev-private/uploads//notes.pdf"], + "responseJsonSchema": { + "type": "object", + "properties": { + "summary": { "type": "string" } + }, + "required": ["summary"] + } +} +``` + +Example response: + +```json +{ + "result": { + "summary": "..." + }, + "model": "vertex model name", + "latencyMs": 1200, + "requestId": "uuid" +} +``` + +## 5) Rapid order helpers + +### Transcribe + +```text +POST /core/rapid-orders/transcribe +``` + +Example request: + +```json +{ + "audioFileUri": "gs://krow-workforce-dev-private/uploads//note.m4a", + "locale": "en-US", + "promptHints": ["staffing order", "shift details"] +} +``` + +### Parse + +```text +POST /core/rapid-orders/parse +``` + +Example request: + +```json +{ + "text": "Need two baristas tomorrow from 8am to 4pm at Google Mountain View Cafe", + "locale": "en-US", + "timezone": "America/Los_Angeles" +} +``` + +## 6) Verification routes + +### Create verification + +```text +POST /core/verifications +``` + +Example request: + +```json +{ + "type": "attire", + "subjectType": "staff", + "subjectId": "staff-uuid", + "fileUri": "gs://krow-workforce-dev-private/uploads//attire.jpg", + "rules": { + "label": "black shoes" + } +} +``` + +### Get verification + +```text +GET /core/verifications/:verificationId +``` + +### Manual review + +```text +POST /core/verifications/:verificationId/review +``` + +Example request: + +```json +{ + "decision": "APPROVED", + "note": "Manual review passed" +} +``` + +### Retry + +```text +POST /core/verifications/:verificationId/retry +``` + +## 7) Caveat + +Verification state is not yet stored in `krow-sql-v2`. + +Use these routes now for frontend integration, but do not depend on verification history being durable until the persistence work lands. diff --git a/docs/BACKEND/API_GUIDES/V2/query-api.md b/docs/BACKEND/API_GUIDES/V2/query-api.md new file mode 100644 index 00000000..8e64ba59 --- /dev/null +++ b/docs/BACKEND/API_GUIDES/V2/query-api.md @@ -0,0 +1,151 @@ +# V2 Query API + +Use `query-api-v2` for implemented read screens in the v2 clients. + +Base URL: + +```text +https://krow-query-api-v2-e3g6witsvq-uc.a.run.app +``` + +## 1) Required header + +```http +Authorization: Bearer +``` + +## 2) Route summary + +| Method | Route | Purpose | +| --- | --- | --- | +| `GET` | `/query/tenants/:tenantId/orders` | Order list | +| `GET` | `/query/tenants/:tenantId/orders/:orderId` | Order detail with shifts and roles | +| `GET` | `/query/tenants/:tenantId/businesses/:businessId/favorite-staff` | Favorite staff list | +| `GET` | `/query/tenants/:tenantId/staff/:staffId/review-summary` | Staff rating summary and recent reviews | +| `GET` | `/query/tenants/:tenantId/assignments/:assignmentId/attendance` | Attendance session and event detail | +| `GET` | `/readyz` | Ready check | + +## 3) Order list + +```text +GET /query/tenants/:tenantId/orders +``` + +Optional query params: +- `businessId` +- `status` +- `limit` +- `offset` + +Response shape: + +```json +{ + "items": [ + { + "id": "uuid", + "orderNumber": "ORD-1001", + "title": "Cafe Event Staffing", + "status": "OPEN", + "serviceType": "EVENT", + "startsAt": "2026-03-12T08:00:00.000Z", + "endsAt": "2026-03-12T16:00:00.000Z", + "businessId": "uuid", + "businessName": "Google Mountain View Cafes", + "vendorId": "uuid", + "vendorName": "Legendary Staffing Pool A", + "shiftCount": 1, + "requiredWorkers": 2, + "assignedWorkers": 1 + } + ], + "requestId": "uuid" +} +``` + +## 4) Order detail + +```text +GET /query/tenants/:tenantId/orders/:orderId +``` + +Response shape: + +```json +{ + "id": "uuid", + "orderNumber": "ORD-1001", + "title": "Cafe Event Staffing", + "status": "OPEN", + "businessId": "uuid", + "businessName": "Google Mountain View Cafes", + "vendorId": "uuid", + "vendorName": "Legendary Staffing Pool A", + "shifts": [ + { + "id": "uuid", + "shiftCode": "SHIFT-1", + "title": "Morning Shift", + "status": "OPEN", + "startsAt": "2026-03-12T08:00:00.000Z", + "endsAt": "2026-03-12T16:00:00.000Z", + "requiredWorkers": 2, + "assignedWorkers": 1, + "roles": [ + { + "id": "uuid", + "roleCode": "BARISTA", + "roleName": "Barista", + "workersNeeded": 2, + "assignedCount": 1 + } + ] + } + ], + "requestId": "uuid" +} +``` + +## 5) Favorite staff list + +```text +GET /query/tenants/:tenantId/businesses/:businessId/favorite-staff +``` + +Optional query params: +- `limit` +- `offset` + +## 6) Staff review summary + +```text +GET /query/tenants/:tenantId/staff/:staffId/review-summary +``` + +Optional query params: +- `limit` + +Response includes: +- staff identity +- average rating +- rating count +- recent reviews + +## 7) Assignment attendance detail + +```text +GET /query/tenants/:tenantId/assignments/:assignmentId/attendance +``` + +Response includes: +- assignment status +- shift info +- attendance session +- ordered attendance events +- NFC and geofence validation fields + +## 8) Current boundary + +Frontend should use only these documented reads on `query-api-v2`. + +Do not point dashboard, reports, finance, or other undocumented list/detail views here yet. diff --git a/docs/MILESTONES/M4/planning/m4-api-catalog.md b/docs/MILESTONES/M4/planning/m4-api-catalog.md index b361aee1..d4fc4f11 100644 --- a/docs/MILESTONES/M4/planning/m4-api-catalog.md +++ b/docs/MILESTONES/M4/planning/m4-api-catalog.md @@ -1,233 +1,10 @@ -# M4 API Catalog (Core Only) +# Moved -Status: Active -Date: 2026-03-11 -Owner: Technical Lead -Environment: dev +The canonical v2 backend API docs now live here: -## Frontend source of truth -Use this file and `docs/MILESTONES/M4/planning/m4-core-api-frontend-guide.md` for core endpoint consumption. -Use `docs/MILESTONES/M4/planning/m4-v2-frontend-migration-guide.md` for actual frontend migration sequencing across v2 services. +- `docs/BACKEND/API_GUIDES/V2/README.md` +- `docs/BACKEND/API_GUIDES/V2/core-api.md` +- `docs/BACKEND/API_GUIDES/V2/command-api.md` +- `docs/BACKEND/API_GUIDES/V2/query-api.md` -## Related next-slice contract -Verification pipeline design (attire, government ID, certification): -- `docs/MILESTONES/M4/planning/m4-verification-architecture-contract.md` - -## 1) Scope and purpose -This catalog defines the currently implemented core backend contract for M4. - -## 2) Global API rules -1. Route group in scope: `/core/*`. -2. Compatibility aliases in scope: -- `POST /uploadFile` -> `POST /core/upload-file` -- `POST /createSignedUrl` -> `POST /core/create-signed-url` -- `POST /invokeLLM` -> `POST /core/invoke-llm` -3. Auth model: -- `GET /health` is public in dev -- all other routes require `Authorization: Bearer ` -4. Standard error envelope: -```json -{ - "code": "STRING_CODE", - "message": "Human readable message", - "details": {}, - "requestId": "optional-request-id" -} -``` -5. Response header: -- `X-Request-Id` - -## 3) Core routes - -## 3.1 Upload file -1. Method and route: `POST /core/upload-file` -2. Request format: `multipart/form-data` -3. Fields: -- `file` (required) -- `visibility` (`public` or `private`, optional) -- `category` (optional) -4. Accepted types: -- `application/pdf` -- `image/jpeg` -- `image/jpg` -- `image/png` -5. Max size: `10 MB` (default) -6. Behavior: real upload to Cloud Storage. -7. Success `200`: -```json -{ - "fileUri": "gs://krow-workforce-dev-private/uploads//...", - "contentType": "application/pdf", - "size": 12345, - "bucket": "krow-workforce-dev-private", - "path": "uploads//...", - "requestId": "uuid" -} -``` -8. Errors: -- `UNAUTHENTICATED` -- `INVALID_FILE_TYPE` -- `FILE_TOO_LARGE` - -## 3.2 Create signed URL -1. Method and route: `POST /core/create-signed-url` -2. Request: -```json -{ - "fileUri": "gs://krow-workforce-dev-private/uploads//file.pdf", - "expiresInSeconds": 300 -} -``` -3. Security checks: -- bucket must be allowed -- path must be owned by caller (`uploads//...`) -- object must exist -- `expiresInSeconds <= 900` -4. Success `200`: -```json -{ - "signedUrl": "https://storage.googleapis.com/...", - "expiresAt": "2026-02-24T15:22:28.105Z", - "requestId": "uuid" -} -``` -5. Errors: -- `VALIDATION_ERROR` -- `FORBIDDEN` -- `NOT_FOUND` - -## 3.3 Invoke model -1. Method and route: `POST /core/invoke-llm` -2. Request: -```json -{ - "prompt": "...", - "responseJsonSchema": {}, - "fileUrls": [] -} -``` -3. Behavior: -- real Vertex AI call -- model default: `gemini-2.0-flash-001` -- timeout default: `20 seconds` -4. Rate limit: -- `20 requests/minute` per user (default) -- when exceeded: `429 RATE_LIMITED` and `Retry-After` header -5. Success `200`: -```json -{ - "result": {}, - "model": "gemini-2.0-flash-001", - "latencyMs": 367, - "requestId": "uuid" -} -``` -6. Errors: -- `UNAUTHENTICATED` -- `VALIDATION_ERROR` -- `MODEL_TIMEOUT` -- `MODEL_FAILED` -- `RATE_LIMITED` - -## 3.4 Create verification job -1. Method and route: `POST /core/verifications` -2. Auth: required -3. Request: -```json -{ - "type": "attire", - "subjectType": "worker", - "subjectId": "worker_123", - "fileUri": "gs://krow-workforce-dev-private/uploads//file.pdf", - "rules": {} -} -``` -4. Behavior: -- validates `fileUri` ownership -- requires file existence when `UPLOAD_MOCK=false` and `VERIFICATION_REQUIRE_FILE_EXISTS=true` -- enqueues async verification -5. Success `202`: -```json -{ - "verificationId": "ver_123", - "status": "PENDING", - "type": "attire", - "requestId": "uuid" -} -``` -6. Errors: -- `UNAUTHENTICATED` -- `VALIDATION_ERROR` -- `FORBIDDEN` -- `NOT_FOUND` - -## 3.5 Get verification status -1. Method and route: `GET /core/verifications/{verificationId}` -2. Auth: required -3. Success `200`: -```json -{ - "verificationId": "ver_123", - "status": "NEEDS_REVIEW", - "type": "attire", - "requestId": "uuid" -} -``` -4. Errors: -- `UNAUTHENTICATED` -- `FORBIDDEN` -- `NOT_FOUND` - -## 3.6 Review verification -1. Method and route: `POST /core/verifications/{verificationId}/review` -2. Auth: required -3. Request: -```json -{ - "decision": "APPROVED", - "note": "Manual review passed", - "reasonCode": "MANUAL_REVIEW" -} -``` -4. Success `200`: status becomes `APPROVED` or `REJECTED`. -5. Errors: -- `UNAUTHENTICATED` -- `VALIDATION_ERROR` -- `FORBIDDEN` -- `NOT_FOUND` - -## 3.7 Retry verification -1. Method and route: `POST /core/verifications/{verificationId}/retry` -2. Auth: required -3. Success `202`: status resets to `PENDING`. -4. Errors: -- `UNAUTHENTICATED` -- `FORBIDDEN` -- `NOT_FOUND` - -## 3.8 Health -1. Method and route: `GET /health` -2. Success `200`: -```json -{ - "ok": true, - "service": "krow-core-api", - "version": "dev", - "requestId": "uuid" -} -``` - -## 4) Locked defaults -1. Validation library: `zod`. -2. Validation schema location: `backend/core-api/src/contracts/`. -3. Buckets: -- `krow-workforce-dev-public` -- `krow-workforce-dev-private` -4. Model provider: Vertex AI Gemini. -5. Max signed URL expiry: `900` seconds. -6. LLM timeout: `20000` ms. -7. LLM rate limit: `20` requests/minute/user. -8. Verification access mode default: `authenticated`. -9. Verification file existence check default: enabled (`VERIFICATION_REQUIRE_FILE_EXISTS=true`). -10. Verification attire provider default in dev: `vertex` with model `gemini-2.0-flash-lite-001`. -11. Verification government/certification providers: external adapters via configured provider URL/token. +This file is kept only as a compatibility pointer. diff --git a/docs/MILESTONES/M4/planning/m4-core-api-frontend-guide.md b/docs/MILESTONES/M4/planning/m4-core-api-frontend-guide.md index 1a808c04..d5c2c6ba 100644 --- a/docs/MILESTONES/M4/planning/m4-core-api-frontend-guide.md +++ b/docs/MILESTONES/M4/planning/m4-core-api-frontend-guide.md @@ -1,384 +1,9 @@ -# M4 Core API Frontend Guide (Dev) +# Moved -Status: Active -Last updated: 2026-03-11 -Audience: Web and mobile frontend developers +The canonical Core API frontend doc now lives here: -Related guide: -1. `docs/MILESTONES/M4/planning/m4-v2-frontend-migration-guide.md` +- `docs/BACKEND/API_GUIDES/V2/core-api.md` -Scope note: -1. This file documents the core API contract only. -2. For service readiness and migration sequencing across `core-api-v2`, `command-api-v2`, and `query-api-v2`, use the v2 frontend migration guide above. +Start from: -## 1) Base URLs (dev) -1. Core API v2: `https://krow-core-api-v2-e3g6witsvq-uc.a.run.app` -2. Legacy core API: `https://krow-core-api-e3g6witsvq-uc.a.run.app` -3. For new frontend integration on this branch, use the v2 URL. - -## 2) Auth requirements -1. Send Firebase ID token on protected routes: -```http -Authorization: Bearer -``` -2. Health route is public: -- `GET /health` -3. All other routes require Firebase token. - -## 3) Standard error envelope -```json -{ - "code": "STRING_CODE", - "message": "Human readable message", - "details": {}, - "requestId": "uuid" -} -``` - -## 4) Core API endpoints - -## 4.1 Upload file -1. Route: `POST /core/upload-file` -2. Alias: `POST /uploadFile` -3. Content type: `multipart/form-data` -4. Form fields: -- `file` (required) -- `visibility` (optional: `public` or `private`, default `private`) -- `category` (optional) -5. Accepted file types: -- `application/pdf` -- `image/jpeg` -- `image/jpg` -- `image/png` -- `audio/webm` -- `audio/wav` -- `audio/x-wav` -- `audio/mpeg` -- `audio/mp3` -- `audio/mp4` -- `audio/m4a` -- `audio/aac` -- `audio/ogg` -- `audio/flac` -6. Max upload size: `10 MB` (default) -7. Current behavior: real upload to Cloud Storage (not mock) -8. Success `200` example: -```json -{ - "fileUri": "gs://krow-workforce-dev-private/uploads//173...", - "contentType": "application/pdf", - "size": 12345, - "bucket": "krow-workforce-dev-private", - "path": "uploads//173..._file.pdf", - "requestId": "uuid" -} -``` - -## 4.2 Create signed URL -1. Route: `POST /core/create-signed-url` -2. Alias: `POST /createSignedUrl` -3. Request body: -```json -{ - "fileUri": "gs://krow-workforce-dev-private/uploads//file.pdf", - "expiresInSeconds": 300 -} -``` -4. Security checks: -- bucket must be allowed (`krow-workforce-dev-public` or `krow-workforce-dev-private`) -- path must be owned by caller (`uploads//...`) -- object must exist -- `expiresInSeconds` must be `<= 900` -5. Success `200` example: -```json -{ - "signedUrl": "https://storage.googleapis.com/...", - "expiresAt": "2026-02-24T15:22:28.105Z", - "requestId": "uuid" -} -``` -6. Typical errors: -- `400 VALIDATION_ERROR` (bad payload or expiry too high) -- `403 FORBIDDEN` (path not owned by caller) -- `404 NOT_FOUND` (object does not exist) - -## 4.3 Invoke model -1. Route: `POST /core/invoke-llm` -2. Alias: `POST /invokeLLM` -3. Request body: -```json -{ - "prompt": "Return JSON with keys summary and risk.", - "responseJsonSchema": { - "type": "object", - "properties": { - "summary": { "type": "string" }, - "risk": { "type": "string" } - }, - "required": ["summary", "risk"] - }, - "fileUrls": [] -} -``` -4. Current behavior: real Vertex model call (not mock) -- model: `gemini-2.0-flash-001` -- timeout: `20 seconds` -5. Rate limit: -- per-user `20 requests/minute` (default) -- on limit: `429 RATE_LIMITED` -- includes `Retry-After` header -6. Success `200` example: -```json -{ - "result": { "summary": "text", "risk": "Low" }, - "model": "gemini-2.0-flash-001", - "latencyMs": 367, - "requestId": "uuid" -} -``` - -## 4.4 Rapid order transcribe (audio to text) -1. Route: `POST /core/rapid-orders/transcribe` -2. Auth: required -3. Purpose: transcribe uploaded RAPID voice note into text for the RAPID input box. -4. Request body: -```json -{ - "audioFileUri": "gs://krow-workforce-dev-private/uploads//rapid-request.webm", - "locale": "en-US", - "promptHints": ["server", "urgent"] -} -``` -5. Security checks: -- `audioFileUri` must be in allowed bucket -- `audioFileUri` path must be owned by caller (`uploads//...`) -- file existence is required in non-mock upload mode -6. Success `200` example: -```json -{ - "transcript": "Need 2 servers ASAP for 4 hours.", - "confidence": 0.87, - "language": "en-US", - "warnings": [], - "model": "gemini-2.0-flash-001", - "latencyMs": 412, - "requestId": "uuid" -} -``` -7. Typical errors: -- `400 VALIDATION_ERROR` (invalid payload) -- `401 UNAUTHENTICATED` (missing/invalid bearer token) -- `403 FORBIDDEN` (audio path not owned by caller) -- `429 RATE_LIMITED` (model quota per user) -- `502 MODEL_FAILED` (upstream model output/availability) - -## 4.5 Rapid order parse (text to structured draft) -1. Route: `POST /core/rapid-orders/parse` -2. Auth: required -3. Purpose: convert RAPID text into structured one-time order draft JSON for form prefill. -4. Request body: -```json -{ - "text": "Need 2 servers ASAP for 4 hours", - "locale": "en-US", - "timezone": "America/New_York", - "now": "2026-02-27T12:00:00.000Z" -} -``` -5. Success `200` example: -```json -{ - "parsed": { - "orderType": "ONE_TIME", - "isRapid": true, - "positions": [ - { "role": "server", "count": 2 } - ], - "startAt": "2026-02-27T12:00:00.000Z", - "endAt": null, - "durationMinutes": 240, - "locationHint": null, - "notes": null, - "sourceText": "Need 2 servers ASAP for 4 hours" - }, - "missingFields": [], - "warnings": [], - "confidence": { - "overall": 0.72, - "fields": { - "positions": 0.86, - "startAt": 0.9, - "durationMinutes": 0.88 - } - }, - "model": "gemini-2.0-flash-001", - "latencyMs": 531, - "requestId": "uuid" -} -``` -6. Contract notes: -- unknown request keys are rejected (`400 VALIDATION_ERROR`) -- when information is missing/ambiguous, backend returns `missingFields` and `warnings` -- frontend should use output to prefill one-time order and request user confirmation where needed - -## 4.6 Create verification job -1. Route: `POST /core/verifications` -2. Auth: required -3. Purpose: enqueue an async verification job for an uploaded file. -4. Request body: -```json -{ - "type": "attire", - "subjectType": "worker", - "subjectId": "", - "fileUri": "gs://krow-workforce-dev-private/uploads//file.pdf", - "rules": { - "dressCode": "black shoes" - } -} -``` -5. Success `202` example: -```json -{ - "verificationId": "ver_123", - "status": "PENDING", - "type": "attire", - "requestId": "uuid" -} -``` -6. Current machine processing behavior in dev: -- `attire`: live vision check using Vertex Gemini Flash Lite model. -- `government_id`: third-party adapter path (falls back to `NEEDS_REVIEW` if provider is not configured). -- `certification`: third-party adapter path (falls back to `NEEDS_REVIEW` if provider is not configured). - -## 4.7 Get verification status -1. Route: `GET /core/verifications/{verificationId}` -2. Auth: required -3. Purpose: polling status from frontend. -4. Success `200` example: -```json -{ - "verificationId": "ver_123", - "status": "NEEDS_REVIEW", - "type": "attire", - "review": null, - "requestId": "uuid" -} -``` - -## 4.8 Review verification -1. Route: `POST /core/verifications/{verificationId}/review` -2. Auth: required -3. Purpose: final human decision for the verification. -4. Request body: -```json -{ - "decision": "APPROVED", - "note": "Manual review passed", - "reasonCode": "MANUAL_REVIEW" -} -``` -5. Success `200` example: -```json -{ - "verificationId": "ver_123", - "status": "APPROVED", - "review": { - "decision": "APPROVED", - "reviewedBy": "" - }, - "requestId": "uuid" -} -``` - -## 4.9 Retry verification -1. Route: `POST /core/verifications/{verificationId}/retry` -2. Auth: required -3. Purpose: requeue verification to run again. -4. Success `202` example: status resets to `PENDING`. - -## 5) Frontend fetch examples (web) - -## 5.1 Signed URL request -```ts -const token = await firebaseAuth.currentUser?.getIdToken(); -const res = await fetch('https://krow-core-api-v2-e3g6witsvq-uc.a.run.app/core/create-signed-url', { - method: 'POST', - headers: { - Authorization: `Bearer ${token}`, - 'Content-Type': 'application/json', - }, - body: JSON.stringify({ - fileUri: 'gs://krow-workforce-dev-private/uploads//file.pdf', - expiresInSeconds: 300, - }), -}); -const data = await res.json(); -``` - -## 5.2 Model request -```ts -const token = await firebaseAuth.currentUser?.getIdToken(); -const res = await fetch('https://krow-core-api-v2-e3g6witsvq-uc.a.run.app/core/invoke-llm', { - method: 'POST', - headers: { - Authorization: `Bearer ${token}`, - 'Content-Type': 'application/json', - }, - body: JSON.stringify({ - prompt: 'Return JSON with status.', - responseJsonSchema: { - type: 'object', - properties: { status: { type: 'string' } }, - required: ['status'], - }, - }), -}); -const data = await res.json(); -``` - -## 5.3 Rapid audio transcribe request -```ts -const token = await firebaseAuth.currentUser?.getIdToken(); -const res = await fetch('https://krow-core-api-v2-e3g6witsvq-uc.a.run.app/core/rapid-orders/transcribe', { - method: 'POST', - headers: { - Authorization: `Bearer ${token}`, - 'Content-Type': 'application/json', - }, - body: JSON.stringify({ - audioFileUri: 'gs://krow-workforce-dev-private/uploads//rapid-request.webm', - locale: 'en-US', - promptHints: ['server', 'urgent'], - }), -}); -const data = await res.json(); -``` - -## 5.4 Rapid text parse request -```ts -const token = await firebaseAuth.currentUser?.getIdToken(); -const res = await fetch('https://krow-core-api-v2-e3g6witsvq-uc.a.run.app/core/rapid-orders/parse', { - method: 'POST', - headers: { - Authorization: `Bearer ${token}`, - 'Content-Type': 'application/json', - }, - body: JSON.stringify({ - text: 'Need 2 servers ASAP for 4 hours', - locale: 'en-US', - timezone: 'America/New_York', - }), -}); -const data = await res.json(); -``` - -## 6) Notes for frontend team -1. Use canonical `/core/*` routes for new work. -2. Aliases exist only for migration compatibility. -3. `requestId` in responses should be logged client-side for debugging. -4. For 429 on model route, retry with exponential backoff and respect `Retry-After`. -5. Verification routes are now available in dev under `/core/verifications*`. -6. Current verification processing is async and returns machine statuses first (`PENDING`, `PROCESSING`, `NEEDS_REVIEW`, etc.). -7. Full verification design and policy details: - `docs/MILESTONES/M4/planning/m4-verification-architecture-contract.md`. +- `docs/BACKEND/API_GUIDES/V2/README.md` diff --git a/docs/MILESTONES/M4/planning/m4-v2-frontend-migration-guide.md b/docs/MILESTONES/M4/planning/m4-v2-frontend-migration-guide.md index bed3e739..87923395 100644 --- a/docs/MILESTONES/M4/planning/m4-v2-frontend-migration-guide.md +++ b/docs/MILESTONES/M4/planning/m4-v2-frontend-migration-guide.md @@ -1,303 +1,10 @@ -# M4 V2 Frontend Migration Guide +# Moved -Status: Active -Last updated: 2026-03-11 -Audience: Web and mobile frontend developers +The canonical frontend-facing v2 backend docs now live here: -## 1) Purpose -This document tells frontend exactly how to migrate toward the v2 backend services on this branch. +- `docs/BACKEND/API_GUIDES/V2/README.md` +- `docs/BACKEND/API_GUIDES/V2/core-api.md` +- `docs/BACKEND/API_GUIDES/V2/command-api.md` +- `docs/BACKEND/API_GUIDES/V2/query-api.md` -It is intentionally strict about readiness: -1. `core-api-v2` is ready for frontend integration now for uploads, signed URLs, model calls, and verification workflows. -2. `command-api-v2` now has a first real write slice backed by the v2 SQL schema and verified through live smoke tests. -3. `query-api-v2` now has a first real read slice backed by the v2 SQL schema and verified through live smoke tests. - -Frontend should not assume all three services are ready just because they are deployed. - -## 2) Live dev service URLs -1. Core API v2: `https://krow-core-api-v2-e3g6witsvq-uc.a.run.app` -2. Command API v2: `https://krow-command-api-v2-e3g6witsvq-uc.a.run.app` -3. Query API v2: `https://krow-query-api-v2-e3g6witsvq-uc.a.run.app` - -## 3) Readiness summary - -| Service | Status | Frontend guidance | -| --- | --- | --- | -| `core-api-v2` | Ready now with persistence caveat | Use for file upload, signed URLs, model calls, rapid order helpers, and verification flows | -| `command-api-v2` | First production slice | Use for documented v2 write flows only | -| `query-api-v2` | First production slice | Use for documented v2 read flows only | - -## 4) Non-negotiable migration rules -1. Do not point undocumented read screens to `query-api-v2` yet. -2. Do not replace undocumented order, shift, or staffing mutations with `command-api-v2` yet. -3. Do move all new service-style frontend work to `core-api-v2`. -4. Do use command/query v2 for the routes listed in this document when building the new v2 clients. -5. Any new frontend abstraction should separate: - - `core service client` - - `command service client` - - `query service client` - - `legacy Data Connect access` -6. Build the frontend with switchable adapters so the command/query cutover is a client config change, not a rewrite. - -## 5) Auth and headers -All protected v2 routes currently require Firebase ID token: - -```http -Authorization: Bearer -``` - -All services return: -1. `X-Request-Id` response header -2. Standard error envelope: - -```json -{ - "code": "STRING_CODE", - "message": "Human readable message", - "details": {}, - "requestId": "uuid" -} -``` - -Additional rule for command routes: - -```http -Idempotency-Key: -``` - -## 6) What frontend can migrate now - -### 6.1 Move to `core-api-v2` now -1. File uploads -2. Signed download URL generation -3. Rapid order voice transcription -4. Rapid order structured parsing -5. Generic model invocation -6. Verification job creation -7. Verification status polling -8. Manual verification review and retry - -### 6.2 Keep on existing stack for now -1. Business reads -2. Staff reads -3. Shift lists and details outside the documented order detail shape -4. Applications lists and details not yet served by query v2 -5. Payments and reporting reads - -### 6.3 Move to command/query v2 now for the new v2 clients -1. Order creation -2. Order update -3. Order cancel -4. Shift assign staff -5. Shift accept -6. Shift status change -7. Attendance clock-in and clock-out -8. Favorite staff add and remove -9. Staff review create -10. Order list -11. Order detail -12. Favorite staff list -13. Staff review summary -14. Assignment attendance detail - -## 7) Core API v2 routes frontend can use today -Use this service for backend capabilities that should not run directly from the client. - -Important caveat: -1. File storage is real and backed by Google Cloud Storage. -2. Verification job state is not yet persisted to the v2 SQL schema. -3. Frontend can integrate with these routes now, but do not treat verification history as mission-critical durable state yet. - -Base URL: - -```text -https://krow-core-api-v2-e3g6witsvq-uc.a.run.app -``` - -Routes: -1. `POST /core/upload-file` -2. `POST /core/create-signed-url` -3. `POST /core/invoke-llm` -4. `POST /core/rapid-orders/transcribe` -5. `POST /core/rapid-orders/parse` -6. `POST /core/verifications` -7. `GET /core/verifications/:verificationId` -8. `POST /core/verifications/:verificationId/review` -9. `POST /core/verifications/:verificationId/retry` -10. `GET /health` - -For request and response examples, use: -1. `docs/MILESTONES/M4/planning/m4-core-api-frontend-guide.md` -2. `docs/MILESTONES/M4/planning/m4-api-catalog.md` - -## 8) Command API v2 routes ready for the first migration slice -These routes are deployed and backed by the v2 SQL schema. They enforce auth, policy gate, and idempotency. - -Base URL: - -```text -https://krow-command-api-v2-e3g6witsvq-uc.a.run.app -``` - -Routes: -1. `POST /commands/orders/create` -2. `POST /commands/orders/:orderId/update` -3. `POST /commands/orders/:orderId/cancel` -4. `POST /commands/shifts/:shiftId/change-status` -5. `POST /commands/shifts/:shiftId/assign-staff` -6. `POST /commands/shifts/:shiftId/accept` -7. `POST /commands/attendance/clock-in` -8. `POST /commands/attendance/clock-out` -9. `POST /commands/businesses/:businessId/favorite-staff` -10. `DELETE /commands/businesses/:businessId/favorite-staff/:staffId` -11. `POST /commands/assignments/:assignmentId/reviews` -12. `GET /health` -13. `GET /readyz` - -Implemented now: -1. `POST /commands/orders/create` -2. `POST /commands/orders/:orderId/update` -3. `POST /commands/orders/:orderId/cancel` -4. `POST /commands/shifts/:shiftId/change-status` -5. `POST /commands/shifts/:shiftId/assign-staff` -6. `POST /commands/shifts/:shiftId/accept` -7. `POST /commands/attendance/clock-in` -8. `POST /commands/attendance/clock-out` -9. `POST /commands/businesses/:businessId/favorite-staff` -10. `DELETE /commands/businesses/:businessId/favorite-staff/:staffId` -11. `POST /commands/assignments/:assignmentId/reviews` - -Live verification completed on 2026-03-11: -1. order create -2. order update -3. order cancel -4. shift assign staff -5. shift accept -6. shift status change -7. attendance clock-in -8. attendance clock-out -9. favorite add -10. favorite list -11. review create -12. review summary -13. order list/detail -14. attendance detail - -Order creation request contract: - -```json -{ - "tenantId": "uuid", - "businessId": "uuid", - "vendorId": "uuid", - "orderNumber": "ORD-1001", - "title": "Cafe Event Staffing", - "serviceType": "EVENT", - "shifts": [ - { - "shiftCode": "SHIFT-1", - "title": "Morning Shift", - "startsAt": "2026-03-11T08:00:00.000Z", - "endsAt": "2026-03-11T16:00:00.000Z", - "requiredWorkers": 2, - "roles": [ - { - "roleCode": "BARISTA", - "roleName": "Barista", - "workersNeeded": 2 - } - ] - } - ] -} -``` - -Order creation success response: - -```json -{ - "orderId": "uuid", - "orderNumber": "ORD-1001", - "status": "OPEN", - "shiftCount": 1, - "shiftIds": ["uuid"], - "idempotencyKey": "abc-123", - "requestId": "uuid" -} -``` - -Important: -1. This is the first real write slice, not the full command surface. -2. Frontend should migrate only the documented routes. -3. Reuse one idempotency key per user action and never retry with a new key unless the UI is creating a brand new action. -4. The old `501` placeholders for order update, order cancel, shift status change, and shift assign staff are now implemented. - -## 9) Query API v2 routes ready for the first migration slice -Base URL: - -```text -https://krow-query-api-v2-e3g6witsvq-uc.a.run.app -``` - -Current routes: -1. `GET /health` -2. `GET /healthz` -3. `GET /readyz` -4. `GET /query/tenants/:tenantId/orders` -5. `GET /query/tenants/:tenantId/orders/:orderId` -6. `GET /query/tenants/:tenantId/businesses/:businessId/favorite-staff` -7. `GET /query/tenants/:tenantId/staff/:staffId/review-summary` -8. `GET /query/tenants/:tenantId/assignments/:assignmentId/attendance` - -Frontend can point the new v2 clients to these routes now. Frontend should not point any undocumented screen, list, detail page, dashboard, or reporting view to `query-api-v2` yet. - -## 10) Recommended frontend adapter shape -Frontend should isolate backend calls behind service adapters instead of calling routes inline in screens. - -Suggested split: -1. `coreApiClient` -2. `commandApiClient` -3. `queryApiClient` -4. `legacyDataConnectClient` - -Suggested cutover plan: -1. Move service-style operations to `coreApiClient` first. -2. Add `commandApiClient` now as the write path for the documented v2 write routes. -3. Add `queryApiClient` now as the read path for the documented v2 read routes. -4. Keep everything else on `legacyDataConnectClient` until the replacement route exists. -5. Expand migration route-by-route instead of big-bang switching whole apps. - -## 11) Frontend implementation checklist -1. Add three environment variables: - - `CORE_API_V2_BASE_URL` - - `COMMAND_API_V2_BASE_URL` - - `QUERY_API_V2_BASE_URL` -2. Add shared auth header injection using Firebase ID token. -3. Add shared response envelope parsing. -4. Add request ID logging in frontend network layer. -5. Add `Idempotency-Key` generation utility for command calls. -6. Build command/query clients behind feature flags or adapter switches. -7. Start integration with `core-api-v2`, `command-api-v2`, and `query-api-v2` for the documented routes only. - -## 12) Frontend do and do not -Do: -1. Treat `core-api-v2` as the real backend entrypoint for uploads, model work, and verification. -2. Treat documented command/query v2 routes as the real backend entrypoint for the first v2 domain slice. -3. Build migration-safe abstractions now. -4. Keep old reads and writes isolated so they can be swapped cleanly later. - -Do not: -1. Hardcode v2 command success as if business action is complete. -2. Point undocumented dashboards or reports to query v2 yet. -3. Remove current Data Connect code until the replacement route actually exists and is verified. - -## 13) Practical migration sequence -1. Replace existing upload helpers with `core-api-v2`. -2. Replace signed URL generation with `core-api-v2`. -3. Point rapid order helpers to `core-api-v2`. -4. Point attire and document verification flows to `core-api-v2`. -5. Introduce command client wrapper with idempotency header support. -6. Point new v2 order creation, shift accept, attendance, favorites, and reviews flows to `command-api-v2`. -7. Point new v2 order list/detail, favorites, review summary, and attendance detail screens to `query-api-v2`. -8. Point new v2 order update, order cancel, shift assign, and shift status flows to `command-api-v2`. -9. Keep payments, reports, and remaining scheduling mutations on the legacy stack until the replacement routes exist. +This file is kept only as a compatibility pointer. From 1a6132a4850855377b088688c5f6398fd93e8c71 Mon Sep 17 00:00:00 2001 From: Achintha Isuru Date: Thu, 12 Mar 2026 14:17:22 -0400 Subject: [PATCH 12/21] chore: added logo images for each different flavours of the mobile apps. --- apps/mobile/apps/client/assets/logo-dev.png | Bin 0 -> 86895 bytes apps/mobile/apps/client/assets/logo-stage.png | Bin 0 -> 89797 bytes apps/mobile/apps/staff/assets/logo-dev.png | Bin 0 -> 91733 bytes apps/mobile/apps/staff/assets/logo-stage.png | Bin 0 -> 96146 bytes 4 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 apps/mobile/apps/client/assets/logo-dev.png create mode 100644 apps/mobile/apps/client/assets/logo-stage.png create mode 100644 apps/mobile/apps/staff/assets/logo-dev.png create mode 100644 apps/mobile/apps/staff/assets/logo-stage.png diff --git a/apps/mobile/apps/client/assets/logo-dev.png b/apps/mobile/apps/client/assets/logo-dev.png new file mode 100644 index 0000000000000000000000000000000000000000..d7e888f839646d0ce0332b9518b4fd80248ad38f GIT binary patch literal 86895 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

Y!u4a(W$`oc!PIDcBhle0&N%ao_kVQLDF}x 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 literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/assets/logo-stage.png b/apps/mobile/apps/client/assets/logo-stage.png new file mode 100644 index 0000000000000000000000000000000000000000..13650e6da86c594ffeb1518b468d89bc6bcd97cf GIT binary patch literal 89797 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�VIXCxsIYw3<5P3z311Pv*4#gKsrD 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%0A+Rd(8+&5}*(GGDWw(S^ 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%0DH$UX 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 literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/staff/assets/logo-dev.png b/apps/mobile/apps/staff/assets/logo-dev.png new file mode 100644 index 0000000000000000000000000000000000000000..49d71834164b859e8bec9dcb1f7bd6a72f25fd3d GIT binary patch literal 91733 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�n$dPYT>% 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

q47f$w+_`lOIZnJMEPpRibnnIqt@aK^ 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 X@sYf+MBJ9Yq083F&NAPEeeiz(l(2)q literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/staff/assets/logo-stage.png b/apps/mobile/apps/staff/assets/logo-stage.png new file mode 100644 index 0000000000000000000000000000000000000000..7b11e59a8398ff279f52626c257b54ae2bf03e9c GIT binary patch literal 96146 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

-rED8+jq03L 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 Date: Thu, 12 Mar 2026 14:42:11 -0400 Subject: [PATCH 13/21] Add flavor-specific app icons setup for Android and iOS - Create documentation for configuring flavor-specific app icons in mobile applications. - Implement scripts to generate and set up flavor-specific icons for Android and iOS. - Configure iOS schemes to use the appropriate AppIcon asset sets for dev and stage flavors. - Ensure generated icons meet required sizes and formats for both platforms. - Provide troubleshooting steps and CI/CD integration guidelines for automated builds. --- .../src/dev/res/mipmap-hdpi/launcher_icon.png | Bin 0 -> 3771 bytes .../src/dev/res/mipmap-mdpi/launcher_icon.png | Bin 0 -> 2523 bytes .../dev/res/mipmap-xhdpi/launcher_icon.png | Bin 0 -> 5067 bytes .../dev/res/mipmap-xxhdpi/launcher_icon.png | Bin 0 -> 7740 bytes .../dev/res/mipmap-xxxhdpi/launcher_icon.png | Bin 0 -> 10366 bytes .../app/src/dev/res/values/ic_launcher.xml | 5 + .../stage/res/mipmap-hdpi/launcher_icon.png | Bin 0 -> 4089 bytes .../stage/res/mipmap-mdpi/launcher_icon.png | Bin 0 -> 2678 bytes .../stage/res/mipmap-xhdpi/launcher_icon.png | Bin 0 -> 5629 bytes .../stage/res/mipmap-xxhdpi/launcher_icon.png | Bin 0 -> 8736 bytes .../res/mipmap-xxxhdpi/launcher_icon.png | Bin 0 -> 11986 bytes .../app/src/stage/res/values/ic_launcher.xml | 5 + .../apps/client/ios/Flutter/Dev.xcconfig | 2 + .../apps/client/ios/Flutter/Stage.xcconfig | 2 + .../ios/Runner.xcodeproj/project.pbxproj | 18 +-- .../AppIcon-dev.appiconset/Contents.json | 1 + .../Icon-App-1024x1024@1x.png | Bin 0 -> 97224 bytes .../Icon-App-20x20@1x.png | Bin 0 -> 1042 bytes .../Icon-App-20x20@2x.png | Bin 0 -> 2068 bytes .../Icon-App-20x20@3x.png | Bin 0 -> 3107 bytes .../Icon-App-29x29@1x.png | Bin 0 -> 1408 bytes .../Icon-App-29x29@2x.png | Bin 0 -> 3025 bytes .../Icon-App-29x29@3x.png | Bin 0 -> 4551 bytes .../Icon-App-40x40@1x.png | Bin 0 -> 2068 bytes .../Icon-App-40x40@2x.png | Bin 0 -> 4191 bytes .../Icon-App-40x40@3x.png | Bin 0 -> 6359 bytes .../Icon-App-50x50@1x.png | Bin 0 -> 2597 bytes .../Icon-App-50x50@2x.png | Bin 0 -> 5262 bytes .../Icon-App-57x57@1x.png | Bin 0 -> 2972 bytes .../Icon-App-57x57@2x.png | Bin 0 -> 6013 bytes .../Icon-App-60x60@2x.png | Bin 0 -> 6359 bytes .../Icon-App-60x60@3x.png | Bin 0 -> 9805 bytes .../Icon-App-72x72@1x.png | Bin 0 -> 3771 bytes .../Icon-App-72x72@2x.png | Bin 0 -> 7740 bytes .../Icon-App-76x76@1x.png | Bin 0 -> 3960 bytes .../Icon-App-76x76@2x.png | Bin 0 -> 8157 bytes .../Icon-App-83.5x83.5@2x.png | Bin 0 -> 9067 bytes .../AppIcon-stage.appiconset/Contents.json | 1 + .../Icon-App-1024x1024@1x.png | Bin 0 -> 111146 bytes .../Icon-App-20x20@1x.png | Bin 0 -> 1081 bytes .../Icon-App-20x20@2x.png | Bin 0 -> 2212 bytes .../Icon-App-20x20@3x.png | Bin 0 -> 3384 bytes .../Icon-App-29x29@1x.png | Bin 0 -> 1493 bytes .../Icon-App-29x29@2x.png | Bin 0 -> 3217 bytes .../Icon-App-29x29@3x.png | Bin 0 -> 5022 bytes .../Icon-App-40x40@1x.png | Bin 0 -> 2212 bytes .../Icon-App-40x40@2x.png | Bin 0 -> 4567 bytes .../Icon-App-40x40@3x.png | Bin 0 -> 7126 bytes .../Icon-App-50x50@1x.png | Bin 0 -> 2785 bytes .../Icon-App-50x50@2x.png | Bin 0 -> 5834 bytes .../Icon-App-57x57@1x.png | Bin 0 -> 3197 bytes .../Icon-App-57x57@2x.png | Bin 0 -> 6684 bytes .../Icon-App-60x60@2x.png | Bin 0 -> 7126 bytes .../Icon-App-60x60@3x.png | Bin 0 -> 11197 bytes .../Icon-App-72x72@1x.png | Bin 0 -> 4089 bytes .../Icon-App-72x72@2x.png | Bin 0 -> 8736 bytes .../Icon-App-76x76@1x.png | Bin 0 -> 4282 bytes .../Icon-App-76x76@2x.png | Bin 0 -> 9159 bytes .../Icon-App-83.5x83.5@2x.png | Bin 0 -> 10172 bytes .../src/dev/res/mipmap-hdpi/launcher_icon.png | Bin 0 -> 4092 bytes .../src/dev/res/mipmap-mdpi/launcher_icon.png | Bin 0 -> 2703 bytes .../dev/res/mipmap-xhdpi/launcher_icon.png | Bin 0 -> 5514 bytes .../dev/res/mipmap-xxhdpi/launcher_icon.png | Bin 0 -> 8319 bytes .../dev/res/mipmap-xxxhdpi/launcher_icon.png | Bin 0 -> 11188 bytes .../app/src/dev/res/values/ic_launcher.xml | 5 + .../stage/res/mipmap-hdpi/launcher_icon.png | Bin 0 -> 4273 bytes .../stage/res/mipmap-mdpi/launcher_icon.png | Bin 0 -> 2792 bytes .../stage/res/mipmap-xhdpi/launcher_icon.png | Bin 0 -> 5746 bytes .../stage/res/mipmap-xxhdpi/launcher_icon.png | Bin 0 -> 8904 bytes .../res/mipmap-xxxhdpi/launcher_icon.png | Bin 0 -> 12273 bytes .../app/src/stage/res/values/ic_launcher.xml | 5 + .../apps/staff/ios/Flutter/Dev.xcconfig | 2 + .../apps/staff/ios/Flutter/Stage.xcconfig | 2 + .../ios/Runner.xcodeproj/project.pbxproj | 16 +-- .../AppIcon-dev.appiconset/Contents.json | 1 + .../Icon-App-1024x1024@1x.png | Bin 0 -> 102949 bytes .../Icon-App-20x20@1x.png | Bin 0 -> 1074 bytes .../Icon-App-20x20@2x.png | Bin 0 -> 2248 bytes .../Icon-App-20x20@3x.png | Bin 0 -> 3353 bytes .../Icon-App-29x29@1x.png | Bin 0 -> 1434 bytes .../Icon-App-29x29@2x.png | Bin 0 -> 3311 bytes .../Icon-App-29x29@3x.png | Bin 0 -> 4965 bytes .../Icon-App-40x40@1x.png | Bin 0 -> 2248 bytes .../Icon-App-40x40@2x.png | Bin 0 -> 4562 bytes .../Icon-App-40x40@3x.png | Bin 0 -> 6820 bytes .../Icon-App-50x50@1x.png | Bin 0 -> 2789 bytes .../Icon-App-50x50@2x.png | Bin 0 -> 5726 bytes .../Icon-App-57x57@1x.png | Bin 0 -> 3197 bytes .../Icon-App-57x57@2x.png | Bin 0 -> 6531 bytes .../Icon-App-60x60@2x.png | Bin 0 -> 6820 bytes .../Icon-App-60x60@3x.png | Bin 0 -> 10436 bytes .../Icon-App-72x72@1x.png | Bin 0 -> 4092 bytes .../Icon-App-72x72@2x.png | Bin 0 -> 8319 bytes .../Icon-App-76x76@1x.png | Bin 0 -> 4339 bytes .../Icon-App-76x76@2x.png | Bin 0 -> 8829 bytes .../Icon-App-83.5x83.5@2x.png | Bin 0 -> 9644 bytes .../AppIcon-stage.appiconset/Contents.json | 1 + .../Icon-App-1024x1024@1x.png | Bin 0 -> 113900 bytes .../Icon-App-20x20@1x.png | Bin 0 -> 1085 bytes .../Icon-App-20x20@2x.png | Bin 0 -> 2295 bytes .../Icon-App-20x20@3x.png | Bin 0 -> 3552 bytes .../Icon-App-29x29@1x.png | Bin 0 -> 1502 bytes .../Icon-App-29x29@2x.png | Bin 0 -> 3370 bytes .../Icon-App-29x29@3x.png | Bin 0 -> 5211 bytes .../Icon-App-40x40@1x.png | Bin 0 -> 2295 bytes .../Icon-App-40x40@2x.png | Bin 0 -> 4775 bytes .../Icon-App-40x40@3x.png | Bin 0 -> 7361 bytes .../Icon-App-50x50@1x.png | Bin 0 -> 2933 bytes .../Icon-App-50x50@2x.png | Bin 0 -> 5960 bytes .../Icon-App-57x57@1x.png | Bin 0 -> 3343 bytes .../Icon-App-57x57@2x.png | Bin 0 -> 6883 bytes .../Icon-App-60x60@2x.png | Bin 0 -> 7361 bytes .../Icon-App-60x60@3x.png | Bin 0 -> 11442 bytes .../Icon-App-72x72@1x.png | Bin 0 -> 4273 bytes .../Icon-App-72x72@2x.png | Bin 0 -> 8904 bytes .../Icon-App-76x76@1x.png | Bin 0 -> 4470 bytes .../Icon-App-76x76@2x.png | Bin 0 -> 9408 bytes .../Icon-App-83.5x83.5@2x.png | Bin 0 -> 10467 bytes scripts/configure_ios_schemes.sh | 55 ++++++++ scripts/setup_flavor_icons.sh | 133 ++++++++++++++++++ 120 files changed, 237 insertions(+), 17 deletions(-) create mode 100644 apps/mobile/apps/client/android/app/src/dev/res/mipmap-hdpi/launcher_icon.png create mode 100644 apps/mobile/apps/client/android/app/src/dev/res/mipmap-mdpi/launcher_icon.png create mode 100644 apps/mobile/apps/client/android/app/src/dev/res/mipmap-xhdpi/launcher_icon.png create mode 100644 apps/mobile/apps/client/android/app/src/dev/res/mipmap-xxhdpi/launcher_icon.png create mode 100644 apps/mobile/apps/client/android/app/src/dev/res/mipmap-xxxhdpi/launcher_icon.png create mode 100644 apps/mobile/apps/client/android/app/src/dev/res/values/ic_launcher.xml create mode 100644 apps/mobile/apps/client/android/app/src/stage/res/mipmap-hdpi/launcher_icon.png create mode 100644 apps/mobile/apps/client/android/app/src/stage/res/mipmap-mdpi/launcher_icon.png create mode 100644 apps/mobile/apps/client/android/app/src/stage/res/mipmap-xhdpi/launcher_icon.png create mode 100644 apps/mobile/apps/client/android/app/src/stage/res/mipmap-xxhdpi/launcher_icon.png create mode 100644 apps/mobile/apps/client/android/app/src/stage/res/mipmap-xxxhdpi/launcher_icon.png create mode 100644 apps/mobile/apps/client/android/app/src/stage/res/values/ic_launcher.xml create mode 100644 apps/mobile/apps/client/ios/Flutter/Dev.xcconfig create mode 100644 apps/mobile/apps/client/ios/Flutter/Stage.xcconfig create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Contents.json create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-1024x1024@1x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-20x20@1x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-20x20@2x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-20x20@3x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-29x29@1x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-29x29@2x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-29x29@3x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-40x40@1x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-40x40@2x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-40x40@3x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-50x50@1x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-50x50@2x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-57x57@1x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-57x57@2x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-60x60@2x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-60x60@3x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-72x72@1x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-72x72@2x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-76x76@1x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-76x76@2x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-83.5x83.5@2x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Contents.json create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-1024x1024@1x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-20x20@1x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-20x20@2x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-20x20@3x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-29x29@1x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-29x29@2x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-29x29@3x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-40x40@1x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-40x40@2x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-40x40@3x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-50x50@1x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-50x50@2x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-57x57@1x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-57x57@2x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-60x60@2x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-60x60@3x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-72x72@1x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-72x72@2x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-76x76@1x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-76x76@2x.png create mode 100644 apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-83.5x83.5@2x.png create mode 100644 apps/mobile/apps/staff/android/app/src/dev/res/mipmap-hdpi/launcher_icon.png create mode 100644 apps/mobile/apps/staff/android/app/src/dev/res/mipmap-mdpi/launcher_icon.png create mode 100644 apps/mobile/apps/staff/android/app/src/dev/res/mipmap-xhdpi/launcher_icon.png create mode 100644 apps/mobile/apps/staff/android/app/src/dev/res/mipmap-xxhdpi/launcher_icon.png create mode 100644 apps/mobile/apps/staff/android/app/src/dev/res/mipmap-xxxhdpi/launcher_icon.png create mode 100644 apps/mobile/apps/staff/android/app/src/dev/res/values/ic_launcher.xml create mode 100644 apps/mobile/apps/staff/android/app/src/stage/res/mipmap-hdpi/launcher_icon.png create mode 100644 apps/mobile/apps/staff/android/app/src/stage/res/mipmap-mdpi/launcher_icon.png create mode 100644 apps/mobile/apps/staff/android/app/src/stage/res/mipmap-xhdpi/launcher_icon.png create mode 100644 apps/mobile/apps/staff/android/app/src/stage/res/mipmap-xxhdpi/launcher_icon.png create mode 100644 apps/mobile/apps/staff/android/app/src/stage/res/mipmap-xxxhdpi/launcher_icon.png create mode 100644 apps/mobile/apps/staff/android/app/src/stage/res/values/ic_launcher.xml create mode 100644 apps/mobile/apps/staff/ios/Flutter/Dev.xcconfig create mode 100644 apps/mobile/apps/staff/ios/Flutter/Stage.xcconfig create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Contents.json create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-1024x1024@1x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-20x20@1x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-20x20@2x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-20x20@3x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-29x29@1x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-29x29@2x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-29x29@3x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-40x40@1x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-40x40@2x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-40x40@3x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-50x50@1x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-50x50@2x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-57x57@1x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-57x57@2x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-60x60@2x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-60x60@3x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-72x72@1x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-72x72@2x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-76x76@1x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-76x76@2x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-83.5x83.5@2x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Contents.json create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-1024x1024@1x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-20x20@1x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-20x20@2x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-20x20@3x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-29x29@1x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-29x29@2x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-29x29@3x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-40x40@1x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-40x40@2x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-40x40@3x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-50x50@1x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-50x50@2x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-57x57@1x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-57x57@2x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-60x60@2x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-60x60@3x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-72x72@1x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-72x72@2x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-76x76@1x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-76x76@2x.png create mode 100644 apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-83.5x83.5@2x.png create mode 100644 scripts/configure_ios_schemes.sh create mode 100755 scripts/setup_flavor_icons.sh diff --git a/apps/mobile/apps/client/android/app/src/dev/res/mipmap-hdpi/launcher_icon.png b/apps/mobile/apps/client/android/app/src/dev/res/mipmap-hdpi/launcher_icon.png new file mode 100644 index 0000000000000000000000000000000000000000..d49bbb8c74721f0c24f44cf0c57eedbc0e4664ef GIT binary patch literal 3771 zcmai12QVDmw_ilru#)HzqDQn?Eks?NXsd+CVs+7CvAR{mDiN%W-XdCvUJ_O>(Gs65 zA-WK&xA0jt{+oF-Z|1$3H*fBoduGnLzkBXI?aqyd8ft^CvtI`Q03cl*4HFXA`AalZ zr1{BCgEonAJLs4g006=F0Dy>>0KgeZ6tNBf_<;d{O`E0Ppc_IlbH zfUCcwu)QpeBmp9HEPVk07JJ0B;2maB`WU4C7<1Ib$+ zx*DoxfipYVAqcZ6)PTy`+`z6I<$5H9yzdSZm`drUE!Y;Ou5O=!*LN?I=ArBRRHs`C z4bfjg#@-IVydR%5ENhlBy^{=^y)6s8JNv2chXb|!Ap_e@@k8*QtPXeacjdiDmn)Ce zZ~+z~x8ow$6&m=G%-0rtmDh;!ogw|JBF}s)b;zmdyBbttOa&ps)k&3Epv1c|5J2n4 z8N!2wpZ8M9wUT1d;WYgMg=WVR&w9_2Z|+@C@fzQp$E{XT(pb@!e~97|jb0|3<^e`} zjTWStDv>!H2GgK%lpB*2*Qy1cnDyL9cW&mdQWg4@!t=Dj+3q!0GADRR)(bg;d0_z2 zO-T>p5sDcc>dsflSQLBJ%~sVm;pC<9;oan4bkpKc`($rdN8&rq zA8ambjKEsgy0kGA%^^;oJ`^^&1ClwNYkrTmy_ zTK}xI-Qw$gyj$Wl6?P;`P~!%gG@L%ES!>lJd&2lF;;^Ul=frm&YPzng%RPs$nUVe+ zI{eTwBgT+5&WY1QwqCTu_J{uX{xM%J^3EDg{LZatNyu{Dz}rB8vlFGc0VsYR2NZ)F zdd$m*9un-#&2GY)68f4wujL1lA1=EZ0TJhxP;H$zPxjX(bCVa;^BzTu3aPTNGFrD_ z`eH%+o15UzNxfHte1jdRd2g>P_TmUHaX{zZ!=}R5Dfi4*CKMqjO;bGVJZnRO62l|$ zs1qJuHhxm1BvlFq^~6(u)RHw6k%wQY{UZE3hWE*Fs?*1GO^UI(FLn#xG1z{WJZ4}} z4NKxOI{GSWtetHCeZtnlExZ-Smx7L}o+e#=x^ikuidTDx zUAoLt+J3O&RhYG?4h@lSw(H~N#EbS4=JK4ch64N3laraqhol$kTuAa2?^3u?_?{+|`dhrZ z@vyIao^$QQ5?z{dk7eq<-*QtuObtk?1&1f(>ppyk&i>K7^&8$IkDgG1n5gMJ zZ6Mq*wy|U`^*72z=%Lm1TGJzU_fy9@p(axO&VO^v0 zHrMNdt+CHFTw?KA(uLeAM*Br8QHkd9o6sj@1{1SnB|odTYG85Ew)Z5K~O4r@)Xe zz*wE8r7Yxp4I{q|sRSSepYb%KB!?o4)P@oUe6olTfKa_U1NpM|NuVCKsX*&}=Z6jW z{Zj%R*SN4JT`#IU)mssYQy9&0?~#s?ma6n5Or8t@K z>Vd<|m^d6?17)D2VW78aEt0dSdG3LKahVFNjy1L|QUQG-hq*b?MDF^!4JxCU(YhB@o;wa5KQf{YU z5!=|_i*OIe^ZdZGexboFzD$|^flDdWD{(2IFKJKHAtE#}GJ^ledsHMIF0|6Xi2QL{ ze!*kce;@K+otk+O=C(%I( {J}M7K6-YCJx5IV?El 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 literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/android/app/src/dev/res/mipmap-xxhdpi/launcher_icon.png b/apps/mobile/apps/client/android/app/src/dev/res/mipmap-xxhdpi/launcher_icon.png new file mode 100644 index 0000000000000000000000000000000000000000..6779c5b9faa4035189a99a1ba594bd2e50997634 GIT binary patch literal 7740 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 literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/android/app/src/dev/res/values/ic_launcher.xml b/apps/mobile/apps/client/android/app/src/dev/res/values/ic_launcher.xml new file mode 100644 index 00000000..72e01a91 --- /dev/null +++ b/apps/mobile/apps/client/android/app/src/dev/res/values/ic_launcher.xml @@ -0,0 +1,5 @@ + + + + + diff --git a/apps/mobile/apps/client/android/app/src/stage/res/mipmap-hdpi/launcher_icon.png b/apps/mobile/apps/client/android/app/src/stage/res/mipmap-hdpi/launcher_icon.png new file mode 100644 index 0000000000000000000000000000000000000000..d4c42c190faedbab35d48f69fac859e2d2f3fe30 GIT binary patch literal 4089 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 literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/android/app/src/stage/res/mipmap-mdpi/launcher_icon.png b/apps/mobile/apps/client/android/app/src/stage/res/mipmap-mdpi/launcher_icon.png new file mode 100644 index 0000000000000000000000000000000000000000..c790375ad590e7c2c3b2b051fccc80a7c7993510 GIT binary patch literal 2678 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 literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/android/app/src/stage/res/mipmap-xxhdpi/launcher_icon.png b/apps/mobile/apps/client/android/app/src/stage/res/mipmap-xxhdpi/launcher_icon.png new file mode 100644 index 0000000000000000000000000000000000000000..6e548385d9ce3f1ba78cee9aeda14c91727f9368 GIT binary patch literal 8736 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 literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/android/app/src/stage/res/mipmap-xxxhdpi/launcher_icon.png b/apps/mobile/apps/client/android/app/src/stage/res/mipmap-xxxhdpi/launcher_icon.png new file mode 100644 index 0000000000000000000000000000000000000000..bd654f8ed9d84bb1b8610166ec6137b2deb46ab2 GIT binary patch literal 11986 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¥Pms)>l62QJrjTVcJ8?M&5b~t z#Xgd!0(@aK`}^SmW@m;79hC&{qLoeM;df<$Em`O0i-Md+7D~F4TF83vM<(v%H*T7P zUtQ1V_(tP|SqejzaV_9#TC1%UbbL z8)3n^JrDgLJHB}Xsq6@-0~Cd%2m7MR64j5r1L24~=Sv4y3JS*7}wF-Yb7U_~wNmd6E30XIxuu}5$ zud@=D=!3-?rIYJ%b=cxiGm#of1s^V&hL^O)q9mje@f^Fk!kJROexlID$BYhg^5@F< z_^Gh=Gj5m2u>JH8OX5(ts z?89peatB&!5v2DeHVPksqHLR;?i$bJj{(85wB(NGpsa<%u~a-u0qfMQA4a zR#~zd9olAoRW1s#lQi-QgcxUK-2RbqFf{Nab + + + + diff --git a/apps/mobile/apps/client/ios/Flutter/Dev.xcconfig b/apps/mobile/apps/client/ios/Flutter/Dev.xcconfig new file mode 100644 index 00000000..1cf7844f --- /dev/null +++ b/apps/mobile/apps/client/ios/Flutter/Dev.xcconfig @@ -0,0 +1,2 @@ +// Build configuration for dev flavor - use AppIcon-dev +ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon-dev diff --git a/apps/mobile/apps/client/ios/Flutter/Stage.xcconfig b/apps/mobile/apps/client/ios/Flutter/Stage.xcconfig new file mode 100644 index 00000000..1c32ddd9 --- /dev/null +++ b/apps/mobile/apps/client/ios/Flutter/Stage.xcconfig @@ -0,0 +1,2 @@ +// Build configuration for stage flavor - use AppIcon-stage +ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon-stage diff --git a/apps/mobile/apps/client/ios/Runner.xcodeproj/project.pbxproj b/apps/mobile/apps/client/ios/Runner.xcodeproj/project.pbxproj index b4c57563..d03d2b39 100644 --- a/apps/mobile/apps/client/ios/Runner.xcodeproj/project.pbxproj +++ b/apps/mobile/apps/client/ios/Runner.xcodeproj/project.pbxproj @@ -256,7 +256,7 @@ ); runOnlyForDeploymentPostprocessing = 0; shellPath = /bin/sh; - shellScript = "/bin/sh \"$FLUTTER_ROOT/packages/flutter_tools/bin/xcode_backend.sh\" build"; + shellScript = "/bin/sh \"$FLUTTER_ROOT/packages/flutter_tools/bin/xcode_backend.sh\" build\n"; }; BC26E38F2F5F614000517BDF /* ShellScript */ = { isa = PBXShellScriptBuildPhase; @@ -383,7 +383,7 @@ baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; buildSettings = { APP_NAME = "KROW With Us Business [STAGE]"; - ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + ASSETCATALOG_COMPILER_APPICON_NAME = "AppIcon-stage"; CLANG_ENABLE_MODULES = YES; CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; ENABLE_BITCODE = NO; @@ -563,7 +563,7 @@ baseConfigurationReference = 9740EEB21CF90195004384FC /* Debug.xcconfig */; buildSettings = { APP_NAME = "KROW With Us Business [DEV] "; - ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + ASSETCATALOG_COMPILER_APPICON_NAME = "AppIcon-dev"; CLANG_ENABLE_MODULES = YES; CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; ENABLE_BITCODE = NO; @@ -665,7 +665,7 @@ baseConfigurationReference = 9740EEB21CF90195004384FC /* Debug.xcconfig */; buildSettings = { APP_NAME = "KROW With Us Business [DEV] "; - ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + ASSETCATALOG_COMPILER_APPICON_NAME = "AppIcon-dev"; CLANG_ENABLE_MODULES = YES; CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; ENABLE_BITCODE = NO; @@ -762,7 +762,7 @@ baseConfigurationReference = 9740EEB21CF90195004384FC /* Debug.xcconfig */; buildSettings = { APP_NAME = "KROW With Us Business [STAGE] "; - ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + ASSETCATALOG_COMPILER_APPICON_NAME = "AppIcon-stage"; CLANG_ENABLE_MODULES = YES; CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; ENABLE_BITCODE = NO; @@ -951,7 +951,7 @@ baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; buildSettings = { APP_NAME = "KROW With Us Business [DEV] "; - ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + ASSETCATALOG_COMPILER_APPICON_NAME = "AppIcon-dev"; CLANG_ENABLE_MODULES = YES; CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; ENABLE_BITCODE = NO; @@ -1040,7 +1040,7 @@ baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; buildSettings = { APP_NAME = "KROW With Us Business [STAGE]"; - ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + ASSETCATALOG_COMPILER_APPICON_NAME = "AppIcon-stage"; CLANG_ENABLE_MODULES = YES; CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; ENABLE_BITCODE = NO; @@ -1220,7 +1220,7 @@ baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; buildSettings = { APP_NAME = "KROW With Us Business [DEV] "; - ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + ASSETCATALOG_COMPILER_APPICON_NAME = "AppIcon-dev"; CLANG_ENABLE_MODULES = YES; CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; ENABLE_BITCODE = NO; @@ -1311,7 +1311,7 @@ baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; buildSettings = { APP_NAME = "KROW With Us Business [STAGE] "; - ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + ASSETCATALOG_COMPILER_APPICON_NAME = "AppIcon-stage"; CLANG_ENABLE_MODULES = YES; CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; ENABLE_BITCODE = NO; diff --git a/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Contents.json b/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Contents.json new file mode 100644 index 00000000..d0d98aa1 --- /dev/null +++ b/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Contents.json @@ -0,0 +1 @@ +{"images":[{"size":"20x20","idiom":"iphone","filename":"Icon-App-20x20@2x.png","scale":"2x"},{"size":"20x20","idiom":"iphone","filename":"Icon-App-20x20@3x.png","scale":"3x"},{"size":"29x29","idiom":"iphone","filename":"Icon-App-29x29@1x.png","scale":"1x"},{"size":"29x29","idiom":"iphone","filename":"Icon-App-29x29@2x.png","scale":"2x"},{"size":"29x29","idiom":"iphone","filename":"Icon-App-29x29@3x.png","scale":"3x"},{"size":"40x40","idiom":"iphone","filename":"Icon-App-40x40@2x.png","scale":"2x"},{"size":"40x40","idiom":"iphone","filename":"Icon-App-40x40@3x.png","scale":"3x"},{"size":"57x57","idiom":"iphone","filename":"Icon-App-57x57@1x.png","scale":"1x"},{"size":"57x57","idiom":"iphone","filename":"Icon-App-57x57@2x.png","scale":"2x"},{"size":"60x60","idiom":"iphone","filename":"Icon-App-60x60@2x.png","scale":"2x"},{"size":"60x60","idiom":"iphone","filename":"Icon-App-60x60@3x.png","scale":"3x"},{"size":"20x20","idiom":"ipad","filename":"Icon-App-20x20@1x.png","scale":"1x"},{"size":"20x20","idiom":"ipad","filename":"Icon-App-20x20@2x.png","scale":"2x"},{"size":"29x29","idiom":"ipad","filename":"Icon-App-29x29@1x.png","scale":"1x"},{"size":"29x29","idiom":"ipad","filename":"Icon-App-29x29@2x.png","scale":"2x"},{"size":"40x40","idiom":"ipad","filename":"Icon-App-40x40@1x.png","scale":"1x"},{"size":"40x40","idiom":"ipad","filename":"Icon-App-40x40@2x.png","scale":"2x"},{"size":"50x50","idiom":"ipad","filename":"Icon-App-50x50@1x.png","scale":"1x"},{"size":"50x50","idiom":"ipad","filename":"Icon-App-50x50@2x.png","scale":"2x"},{"size":"72x72","idiom":"ipad","filename":"Icon-App-72x72@1x.png","scale":"1x"},{"size":"72x72","idiom":"ipad","filename":"Icon-App-72x72@2x.png","scale":"2x"},{"size":"76x76","idiom":"ipad","filename":"Icon-App-76x76@1x.png","scale":"1x"},{"size":"76x76","idiom":"ipad","filename":"Icon-App-76x76@2x.png","scale":"2x"},{"size":"83.5x83.5","idiom":"ipad","filename":"Icon-App-83.5x83.5@2x.png","scale":"2x"},{"size":"1024x1024","idiom":"ios-marketing","filename":"Icon-App-1024x1024@1x.png","scale":"1x"}],"info":{"version":1,"author":"xcode"}} \ No newline at end of file diff --git a/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-1024x1024@1x.png b/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-1024x1024@1x.png new file mode 100644 index 0000000000000000000000000000000000000000..33cfd814b4daf3f256a7381f504dbf6343cb8b1e GIT binary patch literal 97224 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

f;L!)C3mLB!si+lIoJ^3fe<07jMXuq_)v zv4l^dF~CRA&v=+(peyCGa62} zxY(P-V?7v`uu%cLYCq^q*En z84Os-;uE`7of@+elfvX+z>$u}vRG zN~b`|00)~;V>joviLqU-hL88h-l$)wB!L4FK_D;?SKPS!QV$3Q*{PZP|53MwJ2*TA zcs(uSZvh*LHp-Re8_d6=>gt0z8M3fOWE-7g9tlb=svm%Ya_(S~9<|sDOs*VV!3~w> zBvV(q5f;E<-x`sKW`w2G4{t9@PT#`p2Ja&~Zo|d_+)+NRx5eWSW!>KtAKIqW@(|Pq z$i|>6pZ5|-wH@XLUAtFiSo{$*_Ch-1eiRKLU<3d-Ps^$vwVAaX>1}6{r(J`#macPk zb!m1?Vig5hlr0x3GD8B*JOK9m33v#Q?T<)jVj%6mdEWW+D+^TxSqLSr=CiX)y8CHH zPejiVy;F8o*B{L?C^Pg4YWxhk|{vGh{8`Pp_^z@1X=Z zRNGr(^EtO))i7a!FHGe9ihC^3)m`DYgfBr4Cn;BemO==KLjwQZ{UhZf<_R4p{=LND zA#B~bDJ^-*lcOLzWV8hSkEQ{m_xmA5zg`_l98ZoN&_mkEfO~V(xB6z}n5^?3tN;OG z7p?*iGP3aHO7ln%E;MiE$WnauCnFFrsK@*f!ORsXotX%>Bt$=85XA;oSg{ZJ!AG|$ zLmDxAn@iaJG*u#(t?gEY7iVG_z#jZ`)>e3suaXLZLnnYw*M?z(Rx40*{JT?<@+A+y z)UhCz4cz)-an9I}k24dZ4Q$Wk1;1Yv z7NC3=P6o~{Q5ZDI{!N4sx6`)~J=ZKX0Cxl9(2tY~8O*4{QZc#2K%j;SEOh(y$)ryt z@FLI#EKUV#UWaT2$q$?N|Kj&#)P~4h$?k_;ire6Q-cfC3u~$hx?E$ps7=t2V6AaC~nxwf;O!L zAy)RqT^FTxuFG`|6p6TVt~-)-{&+7ke*RXzA~xe3ZpNGS~#TZA}S9 zWj&nm{a-5>V2~uUrmG?&mIy4MXjf!JD>YzbByb;C;>3gBG9fjZ71m2qUlpHOP#XeI zH$w{#n12B583|y(4@FLTAj3_l8*E0(y{&y5Pw@*r;xc*{YZs^r$PC9b*H%`VqDmn9 z;^!4i_6NB38;&V6S3h{tAW(v40cW>BabK(61jJ7tcpv0r&oZWWs&feFU`okE$vctf zlenG4Q$)jyoCq819RV2jx~iV5p4s^j7BJ)>wok#YzyFc1O3h3s}n z;hwucPb>nuJ~B^Z?<^WgJw!XYRUm2Q&J9MZ$3XCdntK5HT)9ygAGL3|*`6m!y-1lXe~pAlbR?XS%qf7O;0Gud&}gD|aChNR@2} zU}1Zfs4xcn?4k!fy;W96K=^RO6@=yFRzzb7#mqQ%PXv^MN~kYjj#z#HxSD_}1+M#( z3S7X0(@sU`Q8nd-xpp6E8Z_*8pTw?4!hsR!6P3KVk0rHb+6Q|BxSxnnN>K#bg>!brzPUovUe?Mh`G!=&lH*&2r!xM3c8=iZc(u$YE-eY%c-eADHN4 zZ0jIbUAs58K$?v#xb2a8efFPdM0*BsFHH&agMD7~ZdcK6D+3GhEh61NVrrxlm||Dq zTN!Y9Pq`^u4IzAJ(nT#G$E=`neY6z8lIR(t)xkBCEi_IGwmgIY^?J|6zt(4xz2y<< zDlZ`f+qM%3-~w6<_-s?Wxb*g2pCc{WFEIjZrZ^5;{3qR zTAc$(qhHOI5biE8Aq0|_^9Vc)a9P4Vrv!b5jxDE!Ve&w>RD04bmmupdbQDm$alb z(%ni)gM>5)(kB%>1cdVr&;R{>=epQu@0nR^?pj28E589yyk0a6E6FjhFGqJ8dIXtlM)UG>pZ?w>%spK@CpgxdCX(2ok2d4U=V;Z)l!j^ zuDo<9wnm%|Tl+i_di2^1pudgJ+LPIbv%HC9!ok?FPo96%g;&$SI8u!)?3I7?*)e1&%

cQfDhgnhB8b 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 vJC{b26uZTW%Dp_BMGj?I@Nt+8YBM@ literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-20x20@1x.png b/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-20x20@1x.png new file mode 100644 index 0000000000000000000000000000000000000000..5f527137b52aba726b6930763bafebd39fe1b88a GIT binary patch literal 1042 zcmeAS@N?(olHy`uVBq!ia0vp^A|TAc3?z4jzqJQa3dtTpz6=aiY77hwEes65fIxWPOKfM3*`OwMF1qB}*96m(Hd^&UW z^SA$BzW)FC`9DbZ%l{9juYQP%0m^=gi~D@~(uWU!KLDln9{ZG+|6|$G9~(D)I(+)m z-h}pbKsQP&R`k(tx{=R(k z@9~TOFLxYEs{Y8J`9d$?O=7_t)viA19LwJn7`yTeVN(xY1^TnuipN9^z5HW z=vxMr=Q@6G9zOfmIp-^b`im9Ye$-6-!fE)jsPpsZFaM98`z`PM`qurwdyoHm_woPn z^S}T9|9|o1mr!6Va+L)61^H5fU>$`^(@JP)N1JHKHUXu_Vlzw`7+P2v zm|K||Xd4(<85nHfE&hw5AvZrIGp!Q0hJyj89f2A&;5L+G=B5^xB<2>N=`k|0GBt%* zQf0Ay4^R&uNKbHnT1k0gQ7VI5W_oVoyp7Y6fqrE5ba4!kxSagJi6Kue&aRHpQICyH z#ZgZ&Q83W3(8N(skJD2#Q_>B{inOd`Rok#&(WFUAXILUrMbj26ST$=`+p=k99ucAK z-X7uot&QHH_YYh+apTAp9*wNLg{M+8kDgkPm6)5Ho&Ns8izja$Wxalu_wM1zV+)=< zefxOzk|)pKO9)7a$UJ)UO7_&b1rpC>-!W}Dt$#@6lBSl`F=Mm7W=CB+MZuKzph<;A zU8Px3yVlyNJG-TYnRytfo9pjiuwliHB_UHA9j|U*BlE=JYS*b%uV&q{T3n^Nz}&b< z;apg5Mov~<=GvTK*H61w#aH)cxi2>s_i9-2Y(-I_sdiCfi;zTs76*eviNzeDw6Ffa PpknZJ^>bP0l+XkKq*4Qp literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-20x20@2x.png b/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-20x20@2x.png new file mode 100644 index 0000000000000000000000000000000000000000..da57bdc1c7fce48d61e7c92641fbcf785d3319d4 GIT binary patch literal 2068 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 M$S;h_^^ME@8y|e%cK`qY literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-29x29@2x.png b/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-29x29@2x.png new file mode 100644 index 0000000000000000000000000000000000000000..a1929f2b866e23f25dfd392f4e580b76b4ec016d GIT binary patch literal 3025 zcmZ{m2Qb{-8pi)b*~LbQ7A35b)vdBvB#5=EEvrRK^v)vK=!q63e7Xo(B}x#z_g=y$ zh{zH(k?4^S1QC(D-`trybMMTZGw*q3o^yWlmYFki5^x3>2ptz4000mjZIm%tmH!D4 z4S8Sf)D763x713*L!0GyGnh%EphzyV;#j(qni0C4ycJB(Dx2Q&_P7!>g5 zpH3+si{x1OU1<$o9xAD4hYdp~CY?e2=V&#!;t2mo|ZIw%cO zx0SCs!M?XiS4SRhE`|0=Cd3F)fkL6Xo=$8U8dc)~C3YkONz;VzYKvDW3#scpU!y`H^|@mOUhktv1@aQjLA zNpSXN_!P2egE-qn3*zT`)Y}Ux2m{?}+OLY>n}`YBi?ai)T$wVmb8RolGbQv@wZrXM zn${jx%Us??doO}oJ|ipGn)r%-IMLJFUkq%Fbx0KzM(hvv3cPKU`_!0aw^*Hyw?$E~ z;@-$S^V%sxda$MqC#DH6r!IHe^Ul+buTYh(kG7~4Vbjd$(lRu+dVa;LUMLB$3Y;Cy zv@Nzc9(|!5f6}M&$6MyF3B8F5tkc~`RTV;TN1DmAA49eemlN%j7?Pu>Yx!=+ffA-} z7r_jpBeH~XMa$*h{;BF_2*01k112!R&H#-$67=ApkC1TVga_>|`n=u0zV|%+bd2lW zkmz4yBMWNNAq}Lmw7sqb<{NRlOIPoj$JM+XkPsj2SfwF;T}&Guc3ZrDzphAT{{A}~ zt0+o3dfd!j|4nPmrz~?^9OIR)6PqfX40X^FuS)!lUlQNGEpw_UKyO#?lXllNn)1Dj zpsG!v>nrg{7lsB5ql0vp`Z>v5X8doQnOU24D@$&u+QtR%{%m^etp87@YM8YJz$h_v zlTVXZN!|C@>s`GgsvwMIzFGWv93MJQHK8+*vEkf*EwDny zM(%hFS?e)bD-?=}L(}%}D>Z0D_1r~0(he_su*4!S?^@bje^k_NNb%^=mdeA}nwK$; z>EKCKucYG3Gq05$5^^7#NU_1#NQlQJ)nJRLfiRs`2OXVy4VxNupr%9HDUoiq-!>Fo zW1G=jfWKlS+6DT0V{N~{@Jg6zzS9ThxW-L{j&*UdZ1++CWBFFC#-?DBKISu6<*j9!Z8=bGU`ZZz!0>#e(I@&3+i zeHiTeR83-3kYzHtiV4R-QaxJ=wh2{?ZRq|pHN~OY3{SC~8MNHvWVu~su-~^gWo%Nc zF;KN_pKnRT@QV~S(5(cCc6Ng(Ha!uB7tIRKN}`f~rg!>)@10abX^v#Z!1U4+@+ik# zO*W~$T7$Zy-<-6`ZSD=C8lmpNNi}&4?7szIUkayE>-_FU35z?3XhoaO5=rOV&C1?9 z+=Z?QtG^|w7b9D5CWQ)Nr$$o7uMo>$KMxGNWM)cr$l+93!&(<+Mm$k7bV}n{np&%P z)UJP(V@SR`b8I&U$=ttxaeeUY+3POkkX-G%@3o8$N(N$i)NN8-`{>Mues)DH=wru& zV)JS}2iSfszVA6*_FpRakU%*uF*K-LwfKF@+;?ZgIMtj7!lX+ESiL_wfUhavILpCemh15Vi6@|l#gi7ZQlJiGLc_5B)R;+|f_g?{m5QI?Ge5TXlO_i@kkalDg z?AqVXM@;muO0m9dF`7{ymI?-md>F2Ek*ay36R86g-KP!iWK`z4xuLM!Lgn?|-v6xX zp!9r%S7F*>;d3l?28I^Soluri{&@iN#iSyGd14Vp+y3LMPDQ&!q& z84I*O@N9ryN-i+oRZhJ(RAK*4J>y&6@2D)Trn96^s4U&yr?P&hfZUg1`p8PVol`*Y z?AdlXof5(7J4uRrFrqf4J%9QKyJ*{b2T^`Kj(Gim59R z(|Ra-7To>MGabIVaDR1DYQxEflnnX9}(`-?3$PJN`C|X%ex0Q;Ivg znOlcw89bpJk4Y$|j86*I_dIo|#Ny?bUHts19OEqA_!T8M)s}RxFxCC>j8j}mEL+Tr z?YY4~bAq>#4@Vsy3I*zegAuC$oi`_MVTnbE^@}}F>FNTMefVmHMeqGHj;)zxJ9VEa zH>llte9{6tj+?ZryyYYQ8EwJ3G49elr1pg_=wm+UXK)n38m}9A^>zL=D63aE<2<_? zb+@kSR6&)#i_dRkbjno+qg2@iY=VAm4Nd4}W$d@O>WI194ACwyMLwfysG`8rK=T-+ zT({hdy~9GiOGx|vm^Ai+OxUxqkvdg^f(hCal1C?0Op~*Ve1n3BZrM1%{ZdK0*En+b z4ZArWY3~{In3ot&!$Pj+i%6v=@vQkUKiN*>m~c{`w@XYnKqqQWX!V8~RhaHBPmJDt zj)RvJ=%h$JC?>pYp+9s!=J5#941>Qp=-|k63m2Pg6J1kbLCW2l?zRjmmOaeDOZSe)y9&awQy?BYP_i`pKl)tEpwwp`>$@yGHxCe-c1O?bg z5sW4_pQS5FWgaUAo%i243sAJm8n@!krPV-kdwZ?s7?Q(s6Z`DGc8<9i2mh1o3x%(@4ELKiq8NdXex2VhF1P6( z=?F1qubBKn1E)_9zI5Y(WGm0-{VARiUj& zm1RYy0s^v!43Uj&lwZGj$xGf#-d`^_=bqfpy`Ow?a!<}l&I4;pQ!uL_D*ylh!_16q zY2N8yI|rogx4XXIqB(JIGg~+S5P1;*z$F3z$217H0s!2F0066=0DyJ@0KktaYPQj( zT>!nVn;HSm{#~V%%3K=4f-!Rm0RZ@<|1~<8t<)9`WX8ha#>}e>AZ|X5zGKKL4U)zh zJ7aGmu|C?~cYJ6LpbAk{zXVacq@rrCqNxqh(7pmufIze%5CS;l&;K9<2H*7ejrhL_ zZPq;oG=l7ZD`5QteL}FvK+ON*sH$pTx$<8kk(#6y8i)N~j$N=XHVk>k2Vmll3Pcva zdh87VaE8N-4D7?l*NY;s_726L^bg*b*Kp@><|G#|CS7$l1Te^^u_~!0Xy2;$o0uxz z9t(Zm-{?i^(bCQ&h6t029sQ!PnW4YPPx*9-Re=-ZtA6+(kT|D{J%I(kmZ<2kw>qU0 z*CJ1B$*%z>xV(ee1M}rEnrTv)jzi=7Pn2Ml^-rB1>wuH3p`3VdU^TTWLH&^XI&eS#Uo7Q;jadnN2pfU5BEFUT(-8^ z`1k2_74$sIIp-iFhudATe*grNEUH`6a0nL*sRx%8OwJZ1jFeuX;^>TG_tkcSD7-GV z3Dd7S?!_Gcgd7-$uZOt|Kz;#Q_dg#&jKp8s3v3uVVE3BBy&4x#LV*W-nwLk)wEEGTKDMMKqAw-)gA`~CCGIGI}^b5|YVwM{`aR=^`%J0RoA9=e5ZM}Av zc>*&d`6j14b&Q38 z%B-NU)230*^74W!SH}1~EPlUT#-LX{#}`lNp>3Bm%7-t8bts0f8DQqc83RU@=Hm_- z9wY-No6szM1$5h*vPp_^64C2TUESuj$PP?N+{nu+_**Q8=fb|u#@pqI_oU~Bg0k|7 z22Cr*U^9()Ev&4syGZ+M%ygXCvQ=EW`+H#*N0aGV7lA(~&((vZpkYci)hzFCFwLF& z{StVMdM9Y^D$H~JMrVi>m#D*iy+A>-QXOf^#B0vb=(fs3d@xl|U$iOoQeYM|^_>^f zQnrM1?nU|pzqEVMlT#ku8|Q4fA!lkr@5(?nwuaHux{V8*?>Dp!hbk9hkEFlKlrVO* z7GGuw8J1PXhX~);e2+K!{#lD0Z=U4;Ml5+CKY?>>sDkT>77ry#qu*3aqNhg%jcy|v z$PFLwY3}WHB4RI4&`#_@l{r_3v>W)gkGOX>$UMJVc3XmykbqM4V5&P2RQX;s?5FMU zNFAaao+3QiXzsGLz=3pf;`;kF>&pabq23Kv_AI`0u)GS6Z^=x0B))%M_zp(RR^H+7 zdfY#*_^+;{GGgF$BF@N~=eOo9Yu{_1EiBJwBi;CiD>4x9F^KlM5{kE;Q#_Xkf6VPQ zlNSP#%afn^Z6}c9VzohNW|Gq@Fu$f)?~fjBB%LU$?o%e$_6s4wO`1N1UEInmGJjpvh&Nqv)uID?`lyjzj;4#PaIWcEqG zYC1RTF4Mi^LJQr0I+J(|K{cu>U`$qM*H1bz;mJn>ZijC>8ax6P>ax5pYoIy2oG4`K zE{fiARqjcoWr3JQn)T4kOF5Bm8)YG_?)Md>*Mh$3sx@S2DL1~l{btAVj;4CG)XMZC zaMVL|?!<0aR_VMciIHSWf1 zOph`VQvawcm3H_(eyDK!S((Mo7b~`-$~V{Cfv4l|Y(yiQ^LRaE%rvL9(pVXDWfI8? z_or53avp|SNX+8vQgzPI8oM)DTp9j~LKo8;Beq5ik4wDPIK~wAU))znR~05z6~!$Dr7@` zzC|U}M5#S{i^{CxJ3ZRFFA{JTBGnMG^HySM(!tCo-s0Wuzb8d}vD^5OKN*sAPH>jp zv8PD|zB~EchbJ?0Pdre-gYC1x#hIl>Y^)utBv;$_%J02o@!pj=b-gGvMRXj4gW&k{ z!io$fF~tE2F|wjwXefceuow$~Vp-BeX95YFM8LyBtUx?@vp(ldC$xupBeA&bVy zU=4Qd5gbYX!8YD$LPyNC!-MbR17c-d0s6E2{kwR3PrjG&Og+Nmr&L?(Zxf|X)mg4z zpDG%4;Eo4`r~hj5oysxMQX_n=-w;^jHQ(&cacqaQnK8d-8l><;#%bBxwGG$AW(Ku-UtWDgn@@=#IbQZ~2WP`FRP>$Zz;jCY1?Fl9h zwYZ*auCkhdUXjmam>%VIUt|BBmvEXgOZ>I-cDwu3{@Khy>S!P~A`&5#nN{+Lexx?c z<#uTtDEn8qWAT>I_4eexRBA&sbuha`MlCS2ITx7%yMezBN^?%C^TCJ-%{yd|R$`JB<-f zJkrg5`K)HJw4&sKK=)Axul0v9WQQ-WU(--OTS)&(_GY@6{A_!4+xqBTZ)=Cvi!z== zd>@52O?7HV$P8l2=}{7hi`-idxjo%i9f_67L$+z8ombg39C?`hFjkK3s`pWW;8bnwTnp0rGNi@=`|*zRY;RAc4)wq zZSI>j)O~65-6f%ZL4WU1?hGuB76(c8aoi&C#`;z~UkC7pOC3d?$*!M8rFn$@1MD%u z3!adNp48)$DJP}l)sIazq^G1MdX_74zJ7eq6@Q)(datLZ2`W*Lkct4_y;o=XT+)L) z5gMQ#1diR0>&2uc;6!#XFf<2sF;~*;gUmSN<;{`dIKG*v0YRwC8Yei#Rar;h!lC@@ z*KcNir>X`+R0@wYqatFC&^Hi<7SI|iYe6knhXCA+uj9{{1o=Q4DA9+|foyeBg;C`PC$aUe#h%?-5+=ikx>bs^`1Mrd9-b(}*NJR#?(?P5IWovr zm*8t#slol zF6f>0iEJ<`op3tjOot~n)1vY;b0#SE6W!^0$kZ~^XE!@N({dz#qA6^GBE$`AfnX zMIw|J$Z&E@zCh>E5O&bnPpkWVm!K?j z`f%_IY4E0}*gue^KtHVWUk6$#`ICQpKs2Yh4Iy1uiue2tnFuQyQCF5q`=}Q;F&90q z^EbV@*Xs*ArfEM_E<$1sEoUk0s3EO-;e=p@mIcx0B);~g^i1j#-yqX=!1#a@d{pYZ zZ7Z$E7$VQI*BY+Vx=z2(cmBUT4l%Dkm&&U>hYa%v!5+RKcZn&nj?{)^`3({5#OXtu z{EB1r%%dz${>JoT@GU7}wYHEKA7Gn^K@F*s=(`Cd{nS^}4crC2-KlAV{G%~*^5Bog z3D89oPZPT@aG>ME*AnHW#PJtlPk!G8n|F+ebd%QdOJoG}ddD~4P|QKe9IvA_n))Vq ztv-w|>DYvxqh`I1d3pOn8&ek>o072DPQpRVz_U`qRZRcS{W!=(mLL2frq41FmF<2BAW6 z35D{xv~a&bp|<7%Q8gJN-M4Cy3>KDhRwa4sVVS`kPNULH=^{Z~nKx&768Y5^O;6S2 z%8@I8+|*)|W%uPD&Zvw@p?;re%8WXpUe?`=*dWO@(9JLu&g3(rA^?T->HA(MHd2cV z=Tg6$e&TZjQ_R8rwQqEo=MDEh1FsG0w(=8^?f#+5e_ajW`nmBjY8-90+7+`2PI)KO zkIu>L<-}h>3?*z@WrUZ1wY+E`SAca)X*Q^cBVCJHFM6qz`h`;Zt1sT0z5Zp(*xq|Q ztL&!SLFX*_YWsCu&~cFH%u`{QYm@CbdX)A7tOCwHSOEoYzR7S0Xg-`ZOwQcwXF&`H z9FX={=X7IT_PV1qMi}l8e6M;rSt~3(BhV+vU-hVK@OrSxQR7z$!J*&Pkb+1=L7Xt! zdxH7fpf=HCN9_eFCeS9svAF!nQd?5G>XCqhtNnufX5BwM^oydu^(FO)a}`oKGwh$9 z3R7QYW}TfcJBZe4rfM&#H+sXg$S(HmL40}l@WzX?zBd2Q+H?W{ MGqyCUH}p*S4}s}*IRF3v literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-40x40@1x.png b/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-40x40@1x.png new file mode 100644 index 0000000000000000000000000000000000000000..da57bdc1c7fce48d61e7c92641fbcf785d3319d4 GIT binary patch literal 2068 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 SDX8nM8K9x6i>OjYhW`hc^4q-t literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-40x40@3x.png b/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-40x40@3x.png new file mode 100644 index 0000000000000000000000000000000000000000..141c5928b7f312b81bfb5ec11f2623208e23dc3e GIT binary patch literal 6359 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 literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-50x50@2x.png b/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-50x50@2x.png new file mode 100644 index 0000000000000000000000000000000000000000..256ba40455a50af2d794cb93baacc75395a7d5a4 GIT binary patch literal 5262 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 literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-57x57@1x.png b/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-57x57@1x.png new file mode 100644 index 0000000000000000000000000000000000000000..b54d709072e086aa92f93d6c8ee2cc01ceea257b GIT binary patch literal 2972 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 Vi~Mk#>Z3RL413z@u;`;J%OGzBf0N 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 NAoEGOO42y^e*hXzYtjG! literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-60x60@2x.png b/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-60x60@2x.png new file mode 100644 index 0000000000000000000000000000000000000000..141c5928b7f312b81bfb5ec11f2623208e23dc3e GIT binary patch literal 6359 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 literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-72x72@1x.png b/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-72x72@1x.png new file mode 100644 index 0000000000000000000000000000000000000000..7febd04de3f03d66b24b24eefa223cd605735599 GIT binary patch literal 3771 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 literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-72x72@2x.png b/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-72x72@2x.png new file mode 100644 index 0000000000000000000000000000000000000000..bb430049638d22290dac24d34b48e4e4c820a5e1 GIT binary patch literal 7740 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 literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-76x76@2x.png b/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-76x76@2x.png new file mode 100644 index 0000000000000000000000000000000000000000..31875682a27718ea695b6514eaee51c43b435178 GIT binary patch literal 8157 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 literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-83.5x83.5@2x.png b/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-83.5x83.5@2x.png new file mode 100644 index 0000000000000000000000000000000000000000..eb5f019a3068718081cb9f29e2f1843c2f40b9ca GIT binary patch literal 9067 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Ξ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 _wNc`Ylc;@jzi&sUd%UY%Vf_AV~BQ^aA`h-}y<& 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 literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-20x20@2x.png b/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-20x20@2x.png new file mode 100644 index 0000000000000000000000000000000000000000..8437d8c07337ea1ff062197fb1b8901efcebdcbe GIT binary patch literal 2212 zcmZ{lc{J4j8pprJGGk&YhLmkehEW(48kBv_Hs~U1WRPVTW2`?7SrUmfh_YPySyCaR zY-Mc>(V()-7(z*wvc;6GJDq#ZJ?GwY?)jYO^FHVOoY(W5_g_z{gPnya^avCH08uMT zQ!G!F{}e=s_oweQ5_p2}w#3>3KnxN9;*$Vii)Y1u1%Plg04(4D0Fws*hlmBuj{3ZY z&=ngCQ{eZX_s>@qRGuSDv~&vt07=C^#b<>*zQQxXWGh=U@B+Vxn553zE%XA8zoPLF-^nqfemG7&N+8G;H_3073}f-#7aI104>1 zMm#|IKO4yY1fMXn7lHUcjHV{$^yz;uiP3F%$zx!D7^e_la-6f=VFjvy+p&b-ChVwQmu=wMQiI~pZVBX z50pFcnTF3T}KNGfCcof|Hn)<%@VHDXh&JsL^ND+s%JEG5q z$*8MQQd1T7_4d6{e0#6^MP`Fj1#Gb3b?q~I6}F7Yc#;^TpWLLDKh+oKfiQ}XUCp3rRIm*yK8Qo!Yq^M4U2-nC%(oJ zXZPD*VoHOxora0cnRgpR(8BpSjD5GX9Veu&m|7zPeGQm9JJ{-oQ}5ZV{>{=5Qu%z4 z*jjE`Vk(*ocm+ zytrFS@d*m6yNr|~Yx=)gOz}U6mn#3zzzXh|gCgI)itO58? zo-qU>BrtE3I?A8Xg==XSHMtZ7TaB2tOY4T$R%|KQ4Hv(#9Y4ZJoCrwn)Rte$q%9K@ zY`h+9Rwf=uNO$hI7Oj?>9pj1_uwi87$VOMLX*@%IZJL{AG@Nbh$6wFRcyE8e@CXjlI2M~fy17^I zX3P2_ly%4fa+4v^7DY>Z+mb&eG6HH3VlzI0Uhs-a*WPZV5`vl7B1)oY)|aBj8RpLA30ROg2!!Q+yOmd zDG|%04;}2%v>rdqgo%Gf!j4R$)h{*C&+RS0(^q>@;sOGR31^)2`;|#rnobGv3wP)r zH|hRYBMdwKjy=Tv(j){AWqq6AQSdgv#>)*iZt}$h1u2Jo$!(-MW;*95J*fY+9wq`^ z6Cqhh!zVw11m7M^`M7(!iXhlu{Qanbi^$4L0b)=dW{BP$QjVs*?%F>hpxmQXTX)K{`=J9T3#RAe{6T}s?tEu!rs#fH z*EWn{+GWJ-ZNgp#KV49*`?f}9D_-%f!bB~u8GNrKZa{T)YTY80?o#*n?3~p3*3r|I z2&?@OA-0cDprgS%_!(uXGsc>wJvp3~P@Hov-o2z6@`B&&&m`@wAE?3^Uwp0%naQWL zpdN-Nwcv)a^8WLnle?E$AoWj-fb|oCrRJ6wDD=m}G=zc4%8Ho!4UMS&2Nb1egrAJ- zx__z6e7>#W`s&?4z!XE`*iD=M^j|4&@x8-;H3>_oN SsBXN|3s{-inN}O)68;6!SpMq( literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-20x20@3x.png b/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-20x20@3x.png new file mode 100644 index 0000000000000000000000000000000000000000..36b76f8f3893f68e876c6858825da521e6385eed GIT binary patch literal 3384 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 literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-29x29@3x.png b/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-29x29@3x.png new file mode 100644 index 0000000000000000000000000000000000000000..db50635966d4c8c3d5f878bab75817d13a9528e3 GIT binary patch literal 5022 zcmb7|cQ72#yZ(3e61|Hay)L2)(R;!o7SWX^&mZTb{tFEfB1R$r06?OpsS18jlm8R}-ox%O zw&MCAY_^(UJpdq(8vqE40sw9wtgw9mzy|~X99jbave^ItoqK+#f&4=Q?~RUzD&YP< ztGK5k{lOu0*EID40BE`XQ$Q^+=jnrq@2#b$hJT3th>})n`WAHfU~ze?LA>p3yzOOe zJ?$R^AO;eX6atA0iHaGCO3Q+zWF6KcNc_Jcfzs{W4-Dyl7{hlC-hMWo_5gJ!M>m_orc7G^fbyl5 zs*;ia>T!O6w~=w-sNz+xNkcW*lz<%vi=F+sCYFuPvQ*X*g=0&Bfd>->Q>$B^Oh@Zc z4$J7lFjOg`#mx_K+>*5Ji*SDFm%JLG6VEQ#j7P;5``es=GwOF$_0vXDmb-%!Au!h(2a_b$;gkUd~L zsr-#Swu}`eRyAYwir*WNxUqd+>T>&%47Gf@B%5(qN`zOqK)6J|r-5OOaMipq@2eBx zU!%jb9^FW3@YrdCF_DVYJ{_E{eNs=&jY}o%!`bPShUSsP>1%)@*_z+@0B%==$%*B- zmjE#{P{1DU)7N1~JB8+^S|A2_M>fL{*BfWie=jcfQYTq$^{;>;xGX8_fk&Gi84(9L z3jx-*Dt}QI1K_2q&~)WA`UPS>97Ay)54V%W-&Ly`sCtQnm$N*IZh}W-^;;`6vyFYb zY+&zDmMqTKZ;7QDbW9-=9CBRobWqDFH{7oWTROiq-EfH&&Ehf`!34VYY3XA5&2eJ1 z1y6qJ&!9jX?=|1DGWTE{6OwjcJ+csLgCYV95`voI1M3^_wfMNj+2CAhI#btjEqml zNc#X;XC(0|eaQtNmG})M`#+*i8aBEx&Y0Tr$?#)*q-vM1ajW@sHti!0eJyxsFL`(&|7 z6EjD?H+-l4CPc#d3=5g=wY`+=I9k0MQ$@Z~@WgyIV-=b{2!<$hM_2n zbgEY4i$?}~aR9ri{h!}Ai(D!T*io=SI-67CI*FRoV%&o_1hq*so9%{Q^2s%mkPk76 z{*Z)w1aGwJ>WWz3%`pq!T;tN#LFf%|LwESEenb=VZdm9dCx$hFCJxivUuG3cs!MYJ zZaC>q(9b5Y8;&1jMJw*}EHO_u-EOU6x^Rt_m~E%Rn&idK4e+>RvHm%~f@*3Hv`jg% zS!)@vH@NvnO1~5&vuX;fX%?wS79kAV*2+GJCS?lMqs{LGkzzNpWCUtX|;~|#A zdhfKiHd9Ki`&d2^-%(yw`!x~PK=Dwxk%ZCtL`9$d6{;tJA!Ri2OW#bUN*UVuxB-Qa z@h1`K3I6C>$7_p>V{N)00*+FnKD9=FWh3C-Fq}&JtlY0$B0UFzp`HA^;M<6m09UD( z-56@HX8rgL><;Ch{zM7e_4yEs09=72GVGI7}kN{{3C)a+NWPn>`g3@)A>M?>SiZv?GpxB@g?O zrKqm{hVi>C@iBFC>|PvE)fJpQYWwCf-8_>kvTL#sIiuw@ro}MxN3v(QGy&CZ_0MEJ zkfh&n==A8Kk4MTL$LoAg2s3`T*VpO9p1=CaU2lP~nz4pK&Yc>*Ynce&;S!O^S`3=^ zKU-)0=@W3Bh0enl8ARdFPgg_*R$Ni-t!QWY z7TN91{yB#w;u;S-sO)T8B004{ETLf37uB;9pPgaQ-%Z$__DRfW`(pO^TZvC;iW&jV zWE&=W)9rn{8;x8?z!ZsK_KhC@QBsrdA3XKHv%AeD3)e+HefB}aq=)8=Kc;Qp?S~_B zG9s!XE8g(MbE(BU5w@jJ!s(JvcGv4B1H8_QvgMGkZbvJu`GzMfT*#FhL+*F?2WjeZ zM5r;!yCF^Ay1}3)Ub0|KqWHocGV^~^vHw=qL{XAyws)uJ#(kgXHZ^s=haQ>|wnOu+ zI>4TXQ=6<|6=VcE6M4_FYf4y-OUgU|=R*=raYFhR@c=HW9h2`t0(7aalE#x?(80 zF=vqrn8YMbh&NNZxvNLS2EbZ_4ix`ObJ}`T-!(N|I)~@c^y?ktSq@Ei>08lH7oTic z^A2C_XcLA5-gnnW7xisuqILn(dJ}jni_mCX-dGf2d4h+>p5lo6j$I^ua(_#w^b)R7 zWkiv=siu9fy}8c5<&HBYsfn5Vl{0oAAiwRcmq14P6YF~4;S&=kV&McdjnWM}5KXw@F0 znQEHpB_XyG^pW%p`{eGb?h=HL+wmZ$-a>L5z?#M$>gN$Dm$ODSeIG(zXv_jM5&X10 z^Znz2!=dj5XsvX&!=l5k;?1xB#b0CuQ^@?UzwFZF@P30czOQ}uKQ3@+#y?t9gvWp@ zga*O14N(7R#QC1jBNKw4;^_PJ{t9y}kZS$r3(P)6RfL@6Fh?R9d7ymRX`-Ky<1mJKk#Dvg z;K42dvujNA?x_wW92t?;^5w%sA5ZgFL9!g#{+ zBr}3N^65VpC8j=q{_uSE&hvI4Tgh3+aI&TI&uhXXqs>95jmHycCNk{pDO6hsh25r2 zx;t4Beng|M4uGb-dDN~e7S(c3UiO^I%>Uu4asp<{EzfjudAnYoZuc~y5pD|dCnwP% zlg;5%xyaqJKivADc^Z~Ryc)^78%)r&4e}Pd(b*87E1MZM;T*4rz?vETg;o91EaNwU zbcmK^gLPnU4GjOB2}xwL`F;bk6vaSr{sQQSNzV%H5yj)14eoNz1@W8j-GnCdhzPvL zHRtX|kE&m?N~XFwh~P3kgEoJY|L(E)VT5R~dK!qOgb$+hJ^3oowGN?u#8RA^wR6~5 z%!Jf-3ewXG_1?`a=O zSv65-8tTIGAMua8X&;HYP}aRZx5}%kGImsIqOM(GDlU^5d}ltm0pmva;?AxP1E03{ zSCj!qMIc@SQ&`v*N8Z<8xxzlE58pO}LadcGKy)U$VxLzb-!Oq9RD(ASQS${#6TWya zOe4wl%^M(JhyTc1({Ci|#YyC09F2>q-CHI~T^+yAQG(MYMiSk9R%4)KCWB2>v_Ygf zHdKQyT6Nmej8VzOUj85oj>%V3BMIK_mn zSM8)$B4KN5)U_MGD@qL5&GveF1$DWN-4~3ZBMx%4ID`m4{1v}3c^^IPf!le|C5MfA zcsP7r2B2Xs9Wwa&+wjWRmMv~1xV4gXI;#3=;-mWVW5kk$(j{w?p-Mb!R~ll_&{q-Z zVz{Qua@_bRss}6uC1F#o5t58CQ@>`sYVf78pvsBQAE*rx1?d8`E4IWB4p?lMz08M1HHsyRkjW+NgN`JX-4p8dGYg zbV6Rh?i8pxyyLG(nv2}5aw%3rP$|RT48+>VI$_GbNI;Z$H>mrcBEK>#k+S$)B0Rnc z2l8loiuugn$|P`EFSG$ZEz*J`=b4rGUrH~>hdFJ%9=hQ;nvogwIrt1?)@Q5aAUfE4 zWTK>y`_{&Ky|R%_YHrs;xME-?7kv>3Bn zwP;zMB*D>pdFf6wbc>T~_<_n-qo#bRliU^9#rM>{Hk?4bC^$xMDf4=zadG9z-DPIN zbgQkQhOLAY-%=)yv_Z{s$8(1g9ZyvYRX zg9g>WA_vk%BM!swHlV&q*0kFWhou$Hm!|m<5vgrz(sfZjWk3Z4MWcB!>7|%QMvV?d z%d^+^B1J>~dxSWV`WChp*lyWEi6WW*{Seqi0lFQJ<=vum=^ zE@mK?&b&d5Ee80ZK~*r9SMLcjhHN;M9Db3$?3L;?5L+TVZ`gX;W68rN6WBHL$$ntW zMi$#Jf2$yUop8Dh$M1T0tFm!a9z6Kll%+o3&V4&O8vaD{h(|PGEV*QzwXCCCtTGC!+ZJzeCwo+B%ag=89%W$h6=%Qn$jS73R~Dy;j^h{`iACS3 zwTkBfv#Juj1|ctW8fPi z-pc0K$UKl=t;a{NIIs3b83*AHTo`4z6sNMtKUX`~33+ui7yP1}CH2q4GjT{xsc>dS zOg$|?9uy>$u_?R&+1Jk1$yhygH+ETgd$>IFhyNkX&lo7CoNA-oQ-AB4f&?ubuYcB; zMWqNccCb(9B1^2S7w2YsPn96(aHv*#qkKh*C(PebjvHVq zd$qm`JEnDHEo$FA{Xsqc#cz1Ni;AtBkV>6lZ9OnBcqwa9b}0cXQU)H>)nn7SACjj* za6RHG(xfmTvgv9ESE34ijyxwi^Li~WJv*9!QdgaXz>x^Q>)1pJ^zD7Fw2_mIY21+i z_@dz>mR|8pAm92|oDR*)ejexe#CNUO<5d`+@-oZ&;z2vO!d<-f zQG@7H3)nhFHx%{nCA)UP2IQ}fr1I>wjj4BlISYT?U!%kU?BC>WRSUD71@Xe#9gY#A zPnPY}KD(2V6vhizKVBU!XX!97B3t9F#)ncbVoSvxhCf!j=ui9{_*32BnfsT@|9cyw Zn1cQ)J)|@u^zi8f&{BJ$TCZ#!@n7^Am^c6c literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-40x40@1x.png b/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-40x40@1x.png new file mode 100644 index 0000000000000000000000000000000000000000..8437d8c07337ea1ff062197fb1b8901efcebdcbe GIT binary patch literal 2212 zcmZ{lc{J4j8pprJGGk&YhLmkehEW(48kBv_Hs~U1WRPVTW2`?7SrUmfh_YPySyCaR zY-Mc>(V()-7(z*wvc;6GJDq#ZJ?GwY?)jYO^FHVOoY(W5_g_z{gPnya^avCH08uMT zQ!G!F{}e=s_oweQ5_p2}w#3>3KnxN9;*$Vii)Y1u1%Plg04(4D0Fws*hlmBuj{3ZY z&=ngCQ{eZX_s>@qRGuSDv~&vt07=C^#b<>*zQQxXWGh=U@B+Vxn553zE%XA8zoPLF-^nqfemG7&N+8G;H_3073}f-#7aI104>1 zMm#|IKO4yY1fMXn7lHUcjHV{$^yz;uiP3F%$zx!D7^e_la-6f=VFjvy+p&b-ChVwQmu=wMQiI~pZVBX z50pFcnTF3T}KNGfCcof|Hn)<%@VHDXh&JsL^ND+s%JEG5q z$*8MQQd1T7_4d6{e0#6^MP`Fj1#Gb3b?q~I6}F7Yc#;^TpWLLDKh+oKfiQ}XUCp3rRIm*yK8Qo!Yq^M4U2-nC%(oJ zXZPD*VoHOxora0cnRgpR(8BpSjD5GX9Veu&m|7zPeGQm9JJ{-oQ}5ZV{>{=5Qu%z4 z*jjE`Vk(*ocm+ zytrFS@d*m6yNr|~Yx=)gOz}U6mn#3zzzXh|gCgI)itO58? zo-qU>BrtE3I?A8Xg==XSHMtZ7TaB2tOY4T$R%|KQ4Hv(#9Y4ZJoCrwn)Rte$q%9K@ zY`h+9Rwf=uNO$hI7Oj?>9pj1_uwi87$VOMLX*@%IZJL{AG@Nbh$6wFRcyE8e@CXjlI2M~fy17^I zX3P2_ly%4fa+4v^7DY>Z+mb&eG6HH3VlzI0Uhs-a*WPZV5`vl7B1)oY)|aBj8RpLA30ROg2!!Q+yOmd zDG|%04;}2%v>rdqgo%Gf!j4R$)h{*C&+RS0(^q>@;sOGR31^)2`;|#rnobGv3wP)r zH|hRYBMdwKjy=Tv(j){AWqq6AQSdgv#>)*iZt}$h1u2Jo$!(-MW;*95J*fY+9wq`^ z6Cqhh!zVw11m7M^`M7(!iXhlu{Qanbi^$4L0b)=dW{BP$QjVs*?%F>hpxmQXTX)K{`=J9T3#RAe{6T}s?tEu!rs#fH z*EWn{+GWJ-ZNgp#KV49*`?f}9D_-%f!bB~u8GNrKZa{T)YTY80?o#*n?3~p3*3r|I z2&?@OA-0cDprgS%_!(uXGsc>wJvp3~P@Hov-o2z6@`B&&&m`@wAE?3^Uwp0%naQWL zpdN-Nwcv)a^8WLnle?E$AoWj-fb|oCrRJ6wDD=m}G=zc4%8Ho!4UMS&2Nb1egrAJ- zx__z6e7>#W`s&?4z!XE`*iD=M^j|4&@x8-;H3>_oN SsBXN|3s{-inN}O)68;6!SpMq( literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-40x40@2x.png b/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-40x40@2x.png new file mode 100644 index 0000000000000000000000000000000000000000..64a6e05d1441031b29d917e4b8d28efb2e4a1cf0 GIT binary patch literal 4567 zcma)=2Tar5*T;W=$W{bIc2QPQiUlcPSu$nsDSH$s8(9SeYAHijQHE^U$R6^rSCJ(Z z0TDztC?Hd?3P=I}eex!6^1jKNytz5|B;S+IJvTY`=Xf0RZ4x0C2-Eufs^59JuVH z^H2@=`|m33u1F&*bbgvv0RX@*^siB984DheMVde@J$0IGDn=G|SzC2TI9U=3RJROt zaSTMjogX8}4v>UON<*OcAQF*f%1BJq&&<3V}^Zx;O`??@qL;r68Z%9xk z1K|J85Qy|f1Oz&I`~5FQQW6e>{a2DO+14&HbLC&g#Md=2#PKl#&_KF*I~Fu%Is*W6 zyq21>DQa#nFBD~JmJ_!e;ImkzEmV0)g;sM`g&*6XN=bpdc6`a32jPCb!q$z=ns>Ny z-e-$%7*Sp^>@%E+ZdTBqPbqA6=*05*e=?_Q5)r$Jz9z^Y&hJ@PwcqV_(ME^;GYAaK5$qP#DD?e5md(V;trsJNgw4C%Hv$IC~joDdAdf%Q^7YzJJ z9`xvC(sFPYPbCE=by5OgPvS( zP3~pF?H5t8EnRYL@9_rmGlXGvV{KPNg%~XE$}$yGiV@U`vLxME0_wxCC$D973H(v> z+L6Rbc{X-3OXW+tnd6YV7Gg(<|MhF@O!cUH0Oe$;T?D-18$=*YI48Q5zEDX%r!6=K z;}nLEB-e@=rMA|7_X~+V`pXiu%0I^8oA{CMeCsPNY99E&HgxkDav=2FOR*vQfoxxD zLFHN4&=hT7ZF?o%bW_cD@A7iH_nB0KzkV#eT)MF9vdA--pp`8CtQlB4rr*wlBFg>f z*UQL_ga8cm8v&)K;J9iWRMww47O~R0K#gcXpqB9s}QupWn7M&Dd*262_R?VwDr_Kd z(?H#qSTW|?On-<0W;xa{7%y39V^@Gz~@L8E!8*$vT;6??VbKA(s$1NmP zfBy{OEMuz8u@{Xwvj0!0WCK!}3~DWx&X`Qsx+` zwb5^yAUG)en0S(11CD$p6qBe-OHP^wUR0fx64ylo_qV1f@MqJZXO4TGSiR^wQ{o7} zHU10Y-^fJAY@XM$nq7BO$d&&TyQ8V6yINaINLBG8%vx`yF$YAN-|~*jBINCoWtkq3u(UK_bHkAfVxEPJ&lRELgXqSnw=>bX z*8;k3)G^4If0(c_Y&am^m<=jT=M;EsWp6&xZ+3UG-Wqff`Ozl!xAxcH$prFSZu9Pk zB<;!Nh#DY5D7*~y!^Bl+Tb^_$CnMBrmfmD?YuFC&9!3!kA5fd&Z+CUPRQI%ZHuz(4 z5(qN2DXjJj=x}wvG83HEWfqz>>d=oq#6qG){vKNd9tSxGZ-|8r2{v_ow=GRi8qImK z;amt{0a1e}c+)(|8!U7FXutO)av>+zVn$rp1sm!zM`cRm*%q}Wzy=b-m$j#=6l?9h zw=7IQqRVzv@y;)LsS|e0w55zK1vvN*#K3>#yj3 z_lbDekZ{vBVSKVQc&?LIF@qKTiJuK~_n5P0p2hWi2HM#pdEdsz*sL0=M^eB&WCq>Q z)c-i58T9TF&^&rpOl!4EB^jQQAfXk)n$F#I3;u^=}!5#_rYnD>%i~aBJuK77&E=` z{Q0Yfv?S5n5~z!5uAgMcwszO6saxVh(^Fw#&AQx;)qU;=MxCIdPwks?ceH<6HNbJB z9iv0c^E8IEwA>Bfx`E!X%GhqwSjtn++laS3sWpcywTeEY$^AEk;D}_E*+t_(FG;SR z<&z-{)j$gsTfZGoB=IrRc(1vRZ9bd`OQP=J_URB#Xg?m9kTYtLla|J2vS!c|j8B|} z8Wo>TYgGG;u#Fm6V*4i)>{k3=<-8YWUIu)8g08buZetScFY0na6FnvL9>rF0DOAAJ zT)e!*=vJX!KQ{rIlpJ|t{Ht`A+A-z~Oa`^G-6M8~VIQg~Oi#CztL@kI*gM@Qg<|!1 zl?UDr4nHgOsP{lZ*mkoBq;bzFo`KLrRBMny+=)a`eq_E+ER9#!v) zQHw?NraUaDEbdx>e>r*?u4jHDW|s8NJAsg)LL{X1je98C{(bcj)W-W*NJ!!PkHHVX6U|S{!Qc ziuT5+(kYL4CI8@-KN}hq>BHs*wpmyO16=>Kt`~tN zMQgTwc!dz*s%EdtP~~Boww&%FSoVfExwcV~O=%Y)*H^x`>blCL=YP1?J9KE!`f#c` zZa^xx9x8^gxUG%v>){Ic@yv0ucaYprt&7W*SJ}G`G|=PH*qoqV2M)zW=BnO1(@B?V z7FjkdW7cJ_QO^C@G96ecL#sa2qu1$&RG3g|6LiUC zNxdRa$1sN$5LKQ7ZXl_0ac@(A81$I|CPg?IBip<3jO6@|t5R+#y=7GDrjXUwFAvXk z`R0>^JPtnpzPV(7J&B_$y#Y~y?@=`;WIsi3a}DMck92k!_ZK+}TZeF_q(PC*`d#+Y zpy>P+GjmaLU&F6z;vwxuHVT7Nq9~D@Ga{1)N*p@9iBiMMjMR==k?8H5soDwSh7PD& zLmksbePJO~&ASjOAH8NAeI6$ug69^>lKhbDh3^mmv?nad&9Lt1ShvYxT$3DC0dYvpYAmp`(FbtlMAA6C3`6u`7^E3xM zI#EiabPKXkoWkA~T7f^*zVopZk|mAT^N9M)xvbpC_P%RW=Lj6~4Z~kpY<&1Rs3^@} zoBpKuy~A+92vmSt#N_pmH_z?XSyQjPW-x^*4ckr&To;3RzY16AB(Sp{(4sRjy!KpR zn&ZGND2$LC$$r$Bfx)8QL8iLhJEj;KJWS%Z(eQR;r;m>8<6?;BUiEXBykvQfV`p;g z6MfCukcm>4kkVEp{E6?A9p_}gog?^SQwojhZGQRdO|!L=)zPK0qoDX0mX-{zC;u!5 z;~i+}rDJX_n?OU8a(@^QHNsLGrZSvGb^|r&XS?36jQHQV6|uFbDk-k&3+s#rIHcJ` zs(5LgX!ZVPwT8DkH*wW-?g;<7b6)a9sJ?VA4(TcYBpzh@2} zGDybBjZxN!(_f>#9sJ`S7;^8Ha8Y=k%Nn>_uYi5EU!3WQ;$~Py(_C@Y5WHH%%lus0 zRHKR@ab;h@y{Q8_(BXY0Q-D7_T|dcyUr3j$q@+_|9xM(6%Q+aEI{9^JtBa{@iE>q* z+jv*i-JJg5o42zS&{&BK* zIpa>Rc`h+Ky8`{mmly$9d{nL*L!t(&b{! zK58wcpKjjJA2wER1FL`y+T&#%4?Xb8oiu z!bNV;kTx!R)`!8!3z&U@XIzGF~J@}7;?+{|cs zH1)e~*bt*<_o;i$Mo4J}ucy>lWY1QoSSC3jC}5ns+~`w7C$RUc3<-kKkw;G3FLN$K zXmD1dqJp*3fCp<|fU=RD@)1Y3*=M2#op8zwFL7!pbHPb|dUyNn*K%8U1qCI!Q-q~8 zq?Aw$r@vn?a+k_INU5`1@nhgddY22ffvv>~0{yLp%0tx}(FJ1sP1(nP&O$!O6v zeVM(!e%oRp|Kr&uhFwbKORd^{Fm}ALd9;zU^v{?1UeFkyBYb!{q5G zh@Hf|`lSpJ>8ZM4pRJGDb#qO5iA6oz$9xAX&w%qcLBxA7!eY_cksQ(2ptQL@es|W{ z*a-1Fou5;(PrbQ*Po}*T`yk)xGhbRgF6*R(8YwEyvSz(}9AG$n*D})Dqb(e=^35tR zJp8U~klXx4E0|Y*d@fjS$L57`;3?S5-?g6Y6;a~A#^Oeweieg*$TW3B+BW5^RuIK* pX$KH&YzxR$ilg&Q|Nr6Bs1C^`WRk+5DEYSn&{Ee|t5b2n{0CEOmI(j= literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-40x40@3x.png b/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-40x40@3x.png new file mode 100644 index 0000000000000000000000000000000000000000..d49e47f9aedbd55eb41412f062c271ec7793d19a GIT binary patch literal 7126 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 literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-50x50@1x.png b/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-50x50@1x.png new file mode 100644 index 0000000000000000000000000000000000000000..088c02735920be2066e3ccd70471f8f90afd9f0e GIT binary patch literal 2785 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 RkMnN>m?A9UHAcAje*yK-BmMvY literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-50x50@2x.png b/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-50x50@2x.png new file mode 100644 index 0000000000000000000000000000000000000000..9f3a128bda89bccdabf9b88a35ed028ad2d74937 GIT binary patch literal 5834 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 LO?7JTJ0brCV!ZPA literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-57x57@2x.png b/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-57x57@2x.png new file mode 100644 index 0000000000000000000000000000000000000000..5721c210d4108894dec39f208669daf981b8ed7e GIT binary patch literal 6684 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 literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-60x60@2x.png b/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-60x60@2x.png new file mode 100644 index 0000000000000000000000000000000000000000..d49e47f9aedbd55eb41412f062c271ec7793d19a GIT binary patch literal 7126 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 literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-60x60@3x.png b/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-60x60@3x.png new file mode 100644 index 0000000000000000000000000000000000000000..c517817732b1efa4ff3c3dc4343bbf15819f4ba0 GIT binary patch literal 11197 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 literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-72x72@1x.png b/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-72x72@1x.png new file mode 100644 index 0000000000000000000000000000000000000000..c5c3e185969e1173c43f48f066f30fa92084ab10 GIT binary patch literal 4089 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 literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-72x72@2x.png b/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-72x72@2x.png new file mode 100644 index 0000000000000000000000000000000000000000..6fb9d895b0bb9407f6980f1910fe5150b4826a52 GIT binary patch literal 8736 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 literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-76x76@1x.png b/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-76x76@1x.png new file mode 100644 index 0000000000000000000000000000000000000000..97217ce120b974cd17015ec52008fd2e4aecffde GIT binary patch literal 4282 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 BQA7X$ literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-83.5x83.5@2x.png b/apps/mobile/apps/client/ios/Runner/Assets.xcassets/AppIcon-stage.appiconset/Icon-App-83.5x83.5@2x.png new file mode 100644 index 0000000000000000000000000000000000000000..fbbb7d5763769d57e22f4a6060304891be55eb3c GIT binary patch literal 10172 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 JHBx3F{{ayabj$z% literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/staff/android/app/src/dev/res/mipmap-hdpi/launcher_icon.png b/apps/mobile/apps/staff/android/app/src/dev/res/mipmap-hdpi/launcher_icon.png new file mode 100644 index 0000000000000000000000000000000000000000..04dc50707ccbc525205a8aa08cd04674452158ca GIT binary patch literal 4092 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 mknU{(^o;vF~xW`2Q^sN-gh43poFG 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 literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/staff/android/app/src/dev/res/mipmap-xxhdpi/launcher_icon.png b/apps/mobile/apps/staff/android/app/src/dev/res/mipmap-xxhdpi/launcher_icon.png new file mode 100644 index 0000000000000000000000000000000000000000..fe7a9a506374374e115a660da98079281ebdd754 GIT binary patch literal 8319 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 ZgT8R_Ay=GzhW}MZP*KnT)ybKK{STVi%d!9f literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/staff/android/app/src/dev/res/mipmap-xxxhdpi/launcher_icon.png b/apps/mobile/apps/staff/android/app/src/dev/res/mipmap-xxxhdpi/launcher_icon.png new file mode 100644 index 0000000000000000000000000000000000000000..05c99031a8b200ab22d69eca261b22383a5fa34f GIT binary patch literal 11188 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 TMJfRtMFq)At4LKz7>E83G^I*j literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/staff/android/app/src/dev/res/values/ic_launcher.xml b/apps/mobile/apps/staff/android/app/src/dev/res/values/ic_launcher.xml new file mode 100644 index 00000000..72e01a91 --- /dev/null +++ b/apps/mobile/apps/staff/android/app/src/dev/res/values/ic_launcher.xml @@ -0,0 +1,5 @@ + + + + + diff --git a/apps/mobile/apps/staff/android/app/src/stage/res/mipmap-hdpi/launcher_icon.png b/apps/mobile/apps/staff/android/app/src/stage/res/mipmap-hdpi/launcher_icon.png new file mode 100644 index 0000000000000000000000000000000000000000..c9f767bd5d02104935d0e7d01b159349aa9164f0 GIT binary patch literal 4273 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 YjY)y*cCq$0{rd)>4a||R^j%~B1=S}NIRF3v literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/staff/android/app/src/stage/res/mipmap-xhdpi/launcher_icon.png b/apps/mobile/apps/staff/android/app/src/stage/res/mipmap-xhdpi/launcher_icon.png new file mode 100644 index 0000000000000000000000000000000000000000..e4166943fcb739ead4622e98196de8f5b3151639 GIT binary patch literal 5746 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 literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/staff/android/app/src/stage/res/mipmap-xxhdpi/launcher_icon.png b/apps/mobile/apps/staff/android/app/src/stage/res/mipmap-xxhdpi/launcher_icon.png new file mode 100644 index 0000000000000000000000000000000000000000..dbe980a4d1503d3a4a2c03d1e559f8f1e63216d4 GIT binary patch literal 8904 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 MX=SN;Nt4k30eNpdIRF3v literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/staff/android/app/src/stage/res/values/ic_launcher.xml b/apps/mobile/apps/staff/android/app/src/stage/res/values/ic_launcher.xml new file mode 100644 index 00000000..72e01a91 --- /dev/null +++ b/apps/mobile/apps/staff/android/app/src/stage/res/values/ic_launcher.xml @@ -0,0 +1,5 @@ + + + + + diff --git a/apps/mobile/apps/staff/ios/Flutter/Dev.xcconfig b/apps/mobile/apps/staff/ios/Flutter/Dev.xcconfig new file mode 100644 index 00000000..1cf7844f --- /dev/null +++ b/apps/mobile/apps/staff/ios/Flutter/Dev.xcconfig @@ -0,0 +1,2 @@ +// Build configuration for dev flavor - use AppIcon-dev +ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon-dev diff --git a/apps/mobile/apps/staff/ios/Flutter/Stage.xcconfig b/apps/mobile/apps/staff/ios/Flutter/Stage.xcconfig new file mode 100644 index 00000000..1c32ddd9 --- /dev/null +++ b/apps/mobile/apps/staff/ios/Flutter/Stage.xcconfig @@ -0,0 +1,2 @@ +// Build configuration for stage flavor - use AppIcon-stage +ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon-stage diff --git a/apps/mobile/apps/staff/ios/Runner.xcodeproj/project.pbxproj b/apps/mobile/apps/staff/ios/Runner.xcodeproj/project.pbxproj index b3030a13..6aa920e9 100644 --- a/apps/mobile/apps/staff/ios/Runner.xcodeproj/project.pbxproj +++ b/apps/mobile/apps/staff/ios/Runner.xcodeproj/project.pbxproj @@ -384,7 +384,7 @@ baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; buildSettings = { APP_NAME = "KROW With Us [STAGE] "; - ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + ASSETCATALOG_COMPILER_APPICON_NAME = "AppIcon-stage"; CLANG_ENABLE_MODULES = YES; CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; ENABLE_BITCODE = NO; @@ -564,7 +564,7 @@ baseConfigurationReference = 9740EEB21CF90195004384FC /* Debug.xcconfig */; buildSettings = { APP_NAME = "KROW With Us [DEV] "; - ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + ASSETCATALOG_COMPILER_APPICON_NAME = "AppIcon-dev"; CLANG_ENABLE_MODULES = YES; CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; ENABLE_BITCODE = NO; @@ -666,7 +666,7 @@ baseConfigurationReference = 9740EEB21CF90195004384FC /* Debug.xcconfig */; buildSettings = { APP_NAME = "KROW With Us [DEV] "; - ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + ASSETCATALOG_COMPILER_APPICON_NAME = "AppIcon-dev"; CLANG_ENABLE_MODULES = YES; CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; ENABLE_BITCODE = NO; @@ -763,7 +763,7 @@ baseConfigurationReference = 9740EEB21CF90195004384FC /* Debug.xcconfig */; buildSettings = { APP_NAME = "KROW With Us [STAGE] "; - ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + ASSETCATALOG_COMPILER_APPICON_NAME = "AppIcon-stage"; CLANG_ENABLE_MODULES = YES; CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; ENABLE_BITCODE = NO; @@ -954,7 +954,7 @@ baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; buildSettings = { APP_NAME = "KROW With Us [DEV] "; - ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + ASSETCATALOG_COMPILER_APPICON_NAME = "AppIcon-dev"; CLANG_ENABLE_MODULES = YES; CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; ENABLE_BITCODE = NO; @@ -1045,7 +1045,7 @@ baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; buildSettings = { APP_NAME = "KROW With Us [STAGE] "; - ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + ASSETCATALOG_COMPILER_APPICON_NAME = "AppIcon-stage"; CLANG_ENABLE_MODULES = YES; CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; ENABLE_BITCODE = NO; @@ -1225,7 +1225,7 @@ baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; buildSettings = { APP_NAME = "KROW With Us [DEV] "; - ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + ASSETCATALOG_COMPILER_APPICON_NAME = "AppIcon-dev"; CLANG_ENABLE_MODULES = YES; CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; ENABLE_BITCODE = NO; @@ -1314,7 +1314,7 @@ baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; buildSettings = { APP_NAME = "KROW With Us [STAGE] "; - ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + ASSETCATALOG_COMPILER_APPICON_NAME = "AppIcon-stage"; CLANG_ENABLE_MODULES = YES; CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; ENABLE_BITCODE = NO; diff --git a/apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Contents.json b/apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Contents.json new file mode 100644 index 00000000..d0d98aa1 --- /dev/null +++ b/apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Contents.json @@ -0,0 +1 @@ +{"images":[{"size":"20x20","idiom":"iphone","filename":"Icon-App-20x20@2x.png","scale":"2x"},{"size":"20x20","idiom":"iphone","filename":"Icon-App-20x20@3x.png","scale":"3x"},{"size":"29x29","idiom":"iphone","filename":"Icon-App-29x29@1x.png","scale":"1x"},{"size":"29x29","idiom":"iphone","filename":"Icon-App-29x29@2x.png","scale":"2x"},{"size":"29x29","idiom":"iphone","filename":"Icon-App-29x29@3x.png","scale":"3x"},{"size":"40x40","idiom":"iphone","filename":"Icon-App-40x40@2x.png","scale":"2x"},{"size":"40x40","idiom":"iphone","filename":"Icon-App-40x40@3x.png","scale":"3x"},{"size":"57x57","idiom":"iphone","filename":"Icon-App-57x57@1x.png","scale":"1x"},{"size":"57x57","idiom":"iphone","filename":"Icon-App-57x57@2x.png","scale":"2x"},{"size":"60x60","idiom":"iphone","filename":"Icon-App-60x60@2x.png","scale":"2x"},{"size":"60x60","idiom":"iphone","filename":"Icon-App-60x60@3x.png","scale":"3x"},{"size":"20x20","idiom":"ipad","filename":"Icon-App-20x20@1x.png","scale":"1x"},{"size":"20x20","idiom":"ipad","filename":"Icon-App-20x20@2x.png","scale":"2x"},{"size":"29x29","idiom":"ipad","filename":"Icon-App-29x29@1x.png","scale":"1x"},{"size":"29x29","idiom":"ipad","filename":"Icon-App-29x29@2x.png","scale":"2x"},{"size":"40x40","idiom":"ipad","filename":"Icon-App-40x40@1x.png","scale":"1x"},{"size":"40x40","idiom":"ipad","filename":"Icon-App-40x40@2x.png","scale":"2x"},{"size":"50x50","idiom":"ipad","filename":"Icon-App-50x50@1x.png","scale":"1x"},{"size":"50x50","idiom":"ipad","filename":"Icon-App-50x50@2x.png","scale":"2x"},{"size":"72x72","idiom":"ipad","filename":"Icon-App-72x72@1x.png","scale":"1x"},{"size":"72x72","idiom":"ipad","filename":"Icon-App-72x72@2x.png","scale":"2x"},{"size":"76x76","idiom":"ipad","filename":"Icon-App-76x76@1x.png","scale":"1x"},{"size":"76x76","idiom":"ipad","filename":"Icon-App-76x76@2x.png","scale":"2x"},{"size":"83.5x83.5","idiom":"ipad","filename":"Icon-App-83.5x83.5@2x.png","scale":"2x"},{"size":"1024x1024","idiom":"ios-marketing","filename":"Icon-App-1024x1024@1x.png","scale":"1x"}],"info":{"version":1,"author":"xcode"}} \ No newline at end of file diff --git a/apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-1024x1024@1x.png b/apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-1024x1024@1x.png new file mode 100644 index 0000000000000000000000000000000000000000..245225a9a001ee085f3e6745a68548b90ba4554c GIT binary patch literal 102949 zcmZ_$2RN1g{|AoWhm#qOk&Micl$DtsGRjIsgrc%XWF(wZvXUez+1Yz!m4kz<5{m3i z$lm)n_wRMo`}6((f7kW%zTQ_|r*psV`+mKi^YM5*g&F8+(onHcK@dcvt)*@VK}hgd zQka4a{9zeTTMz!=w$U=wg&4>w3O*!%sI7aMe4g|;1M@{8RgNX_5&y%> zrVsDld3aCG#{C}n1G*q~L0VW$LRkEQk+`g!n5>+H%sDYJIWaNS4z5T4e-}8r-nGB~ z=>PiyiRi2*aDm|e?(opw`JTtaJI-$ZuWK$`kdyj%lclW87;p_O@tW(d_aA!SalZ#? z*xNeaNh*1319kw?R=;HAGq`x@{pRjX|Cz_=or`Du(swe2+PsWS9*^mIck7ZyIO{~B zxa(g(JM}T;ecnySUhF9S#_0Rc-tCFI| zZmdT~04z)Y{-%=du8)%AJrmCxcN@c6W$8fk5$^!;&(N6Dho{>)N0UQ7R&Wg#eA zP+Few){fQSiqKlP4spAmt-$m1@^+CN7h^XIa4l)Iee37$OBc;-ixKZzUBNO`3oV~T z{$a_)^Y>&zDqzv{cAb#7V;1KHk*_LJP%7!ZOwdDxnx~ep8#L+Z?XOWG(h~)deVHTVQ_N2a@FzN5 zM7EwozUu9h=26MxtdtB2Cxe!f9Ku6G^MgjIGrHTKy&bb89>xb}@VcR1*{@BG9o_KO z>%Xs`9(@)<(bLmMwGodK?4y&qywTTle?OD@x3>>@i7y_}MN9qlZuchBs~e?qNYh`8 zre+DM(46GatFvh(OJ$reR>gD*Azw)YGm;A_dX?@^+Olk!ZDvk)5)gZcBh? z@=z(#MvMJ^)f!w!&r+6og#ucwNY~T|6tE{Nq)rNXVBvO32aVo@bC@a&Ft=#2pC~dI zq$yHNk&c~I2&D^jV?tz1`N2h9mSzG_c7m_36?g@Ddrn}hXIU6&)~6mMB+9S3R8g+v z=D9Vuhz~4&`;NY+lHAF7O70mP$Yp@X&z5BAT{ihLk4i~F-HzUL|KSIgI@*bubd(C4 z5c8M0<>tp*d11I|VcE2_wo;hIqy9CTfwH<#q`Ky@cn(t#4u5rVQxd%EV0=8sd%RW} zowab8(G8+YJ(?C)xIy*DV?E`@-D}hcJX&717D?m;J4d6JTZ_!vTD$VB$^&?*D%=05thKY zCH}o-?`Xdr>;nzW`VA4qaa^P4XL)ai>UFA#wJB8a&q{E1&i8B(nBGZX4WX?~z%6{; znwzx_yF}@+D@r;hea&Qqyx50q-hCoZTR6XTe9!me0!|_=ZGuSYb0==-XH*bmcr`OC zWYZN-R$}f_&&Oblwam&Q|9G>(HaWtJGJBY~<-$yukc2J5n}2tjHew?UkX|XxCfFMa zCuy$R29WK`YvCR-F*I8HXVB=~Ua5sX(t^%RBmDui38fV2pywWo>L4 zxqP5394=Gl-p88^E04K4`uq3bU|{FYf4wt36NDXQaEAzYi`QIu?&Y__Tc1CVV2MW@ zJ36{SAUgEN2y!U#g2(W(E?wLn!LwoGDmYHH@6X0q;?eXmR}W7LH!QdlPcHOoCZq2faHtC4veJz#)~%IXj$orOv{CN=KORK3aY+x?Tg*X@r3WW%cV{G&rDg3QJ$g2C-aZ>)rW)gN{1LDW^giQNYR>S-Q9s$XLbS3qJt%QM#kMp<(G>7`%keXMqo(+BZza*jZvjW zfanfdQaR!&x88`y8a?ml@E#xWVi!nsX}u#$O4_)BgHwk{k~~|p#Zx4?mPo+cfKaT) zgGo5U{N;TD-<~5*WBv~sCQ{X@J@Dm9KC&okiu`NeL-MH z>gpotA5TH!Ptr9r1C?^T`E112WIK`+`8a)`m6`Z77g*O++O^BR8oSIZ>jufoV>4}T z)tnlyoS{}QJT92eqws3bzSj1}QqJE*`kqy8TZc=5tu-wLLdmnfZ?GUCTbzWSS7)Aw>1QX)Q!=(&oHD(;}rZRTz*E%lBO zJkP<=d$&uydCAo>v*Ad%XiTDYI)@~sXJEZdWe7*_wYwPt4kzR~ze@argcwf(Zv7lM z5U#8uSKY*|_%Nd3jI3DC&h#1=q+EgQA!7&}W~kPJUECGu%M}leo5|ng;GDAzbV{M# zL(aO`4z%#_2=+nIr>CpGwFP5(cMQN~Im*URnVjwmU-K&PAw4cym`$ScFFAig!Q7Y#jjVzA(A{f z>@H$%nUz~kmLXG`H!b;q)hwl3COh}K%bU^uXuR?603Pm~uy}OOXn8C%fe?UqMYGE* z<0ih536sBKyUti=)^!jGHmr5OU`OJO5F+k{cda57*WCOwVdFH3V=n(nH99LTn4dl8@xMdF48XF^ti2G!f$dVmC1VY2f-mS)grYg z20mYWYMUISdguBfjS(fcRH^`mci)fuBPFwQAV06JjX)W`GKeJkx=r1_#Qlt~V>o!H z(duB(&JjmDHR7h$vs}qWdZnNYt@x67t`DCP3xgZNEF?=;;So0>9a*r_W_Gr0AW}EG3*AxAf)^hPmQmEALlDFh=%OpLv4y78Q8kD01Ft zNe*28gj`)(2VCx~d%Xihd`JQyKFZmZ`5GO|#RK+@3*m7!zaRvUB#|72inRLT2H z6H%w7a2Hnw9mOpyjB%D=C(Hj9sp^AW`QYMaJ_gyx+pqlKg9kfH;rF}a-)hQ+Z+i(7nq(aK?SO9dlSZ>~(}=+d83I-X(ZS;THk(mG?$u0qVx_U6Z^Bj1vc zm0uojZnXZH51Wr&S)UD{^=_eku^_#lEz-V2sh^y=S`v9}xA9DBre80^@>rzzh^N$8 zl9)n3!uWez=^BplAiHpt&*@hFgp5!1tvn3UxH+%SZCo8LcLBZkk%TLoZ&*Gb`#+BD8q~Br3{Wowsice>g zfiq!D^94dCmq%&l9_p?XszRSrq^b-56|FB*P~#VFoy;ntTUiEae5>FSBjb<7X+p2{ zySIY=OO8zNei7x%Qx_e3Vbyn{0Ta}pOm01qxL_Eqb|Hs}XyYH$-YLCpAEl*2+&yH1 zS_S4VYXJW?3sJ>T3%)y$$9h-lMJt;Q<-^C8^Wd5ldQPPm5|T!xme6u<0a9Nv$iggl zP7PFmy;l*Kgr-#8DR6aq%~_-=KW7Uo2mji3B_npnQpejnE%MKLulxe~NwO%RTY17| z?B(1--d7$uthd?)%FnlY*bzyf^T-b&fiAY~TP6J>CH69A`Yj<)VYqfiXw7zcjo2ek2@D}8ysbY@2ZC8Hu zQnm57!w+)6l??WKD_564r3oM~a|>U7*}Z#mbyS23@wW&UA!%*;tdb1oVFEL2Lc6&G;ml98uYQ zu}L;&$SCRQ()PX(Z(?1_{7L$#?XE%|j5eR!_9724M0p=>#Tw=Q3@H<+FyL13ebaD8 z`DV{exYWhQK5Trz*0JJv9qXwV`_Qk85EKNtKgb2?_@+$FljosjX%$omqNzmoFIeg0 zon61Mo^slxFVID)J09Zj_o&cYCeLg;RA|Tx>z|M|QUzt(pkv+>0#+3SnH=^)E%4i* zpq_O!g?@Z1$|7!5SCW|$vRK+-z0#KM>rM?FXf@_XU$~^TI8z^cng#rAPM=X>k54+e zXs?~DQ#rDIR$Nih80QkL7dWMk(1@rcQCO+CIWTGtjxCcIzCg`rY$lBqBa7B!BxV5+ zlR)8^7HQ}F6tnuB^$MM`&IA_$A+KnWJR}voI({kp+K<~8-U~u@m>xAhaEft%4?oJI z>=wms;f`I|uXKLUO2v@F$IKe$mTH9scr9{DdE@w-D_e@s=Ik3jUrb>8-W6Y4n`vK> zjZzUJ9;Mbo&M&Fwp}!2S20<^?)=9azy=D`CR&Ct(et#3LDjzCm2EEvwe#yWsGq4}f zyKHUoKix5)D&?~mk@speWI&<&J+n`K=C8zudRpXU+WHndNqa)`57Vt>^kH{;@c*a*N{Px{x8O- z-^F{s8c8YGk9(qu=>YfzaAWnm96~%8#OUxJR7&+>vUUdBVR617Gv!OpjNPyLhQPB@ z84d*Qlacc<=Mhfy$*;Pd3T+ZAWOue_2?qHXSZZr<%=w^uZM1)~uHfx=jT z({)qrqr!sK{wz9kR|c)-_QznOW4}o5zO9>^8urXB7tKLnJgbL;oVeM`xP!Y460)J* zO($eepN@5U>*gERbrPrLGY`O!n|}ch^}D2TyvSna?xCSwGE5V1ebi|t<*l5zv0GL% zRUo{wQyGZtEL4Ptms6{pB9Cq-R;i;AG7Q)QmxS8dnCauq=SAs=p&XSY`vIi_9YH3% zyzITJsFa@vpDHKwVIdGauVDvMjso$ytg*s_i4%G_ZHqaF(uZyejz z(8>_R4wb|G?W@ zw@^velghk_6B3BwCA{>01&UrV3yX!_OKOW1Lr^MeyfvzgP|HM8Ci?HyjDNgBaUU0z zPct_zPy&y1e66pB*85;P4k_sMfd29R!=ATL>|J-8K-hSvl7WOtX^ryfNy|@8fvQ2! zlJ?)mS1ab16!3g``EcPF2XxEeyr1Xfkb2spBa>scvgxRWhBUhp9wp$9kE zKaTD>daihed1K z%NE_+A$e*?Wvqrw(i`22qEPX)C^2Ty55!glLCv?{y>(y&o@8+=eK!(r?Scuo>-c#S z^UB{`+);HS*mu7}lwVZ3TIoJMgFM(#lOlmycnEc*zzln+&%LNmOn9M+@ju{Z#^NJW zP$?Gw%A|C%d1jLH!p3Ng+6xQt0d8!+l<+ceZl0GAEc1#`2{W&JJLfnmEAF>^(Mbt6 zcL^&YcV+RVyjYIW7H!AJQzYqx5!~q;16Nirfb$C3Ac3wE2E}4fWs-;c^Or?qL4-+6 z;pD+s+{$;Te3YNDxm8rU$pxQoLhonwCT_`)fhNplNMl}&i+68BIZ{F?V6R|9`fCS( zkrYg0IH6G*86$Lj!?zX#8#gj??SMaOKbHVhN&&KtJw?-b;_|7PJQ(q3nvojDkTFA& zLKxh2wO_39Zt2g(4YuCrGK|qzCSF9)qi5x{(Z5eOF4xKrUMQi(XC(*w)q)p^1pVMoPm+MC=>1=&irXKx#>s1(@b9`6G93}k~`oR|+t3zh%6T5r36TP2d#S5bR zwT)^yPMfujFXL+?4t-SsF>mP6boHo*%EpAu8 zPX}@THnpSd^}60A3;Ltp=j+69r*3AXTR|ZiyxJO-djm2m?AzR;$L`&?mKi&)0^o#t z!XaqQ^?Y{4Ch7zGo0{xW%!Mwuq5N>$A28)V*$AfRsRSk;=tzfqZ?yYV4nOtoF}~KL zdirUYVc2-snbhVN#<#oXsz&G}WVMJV1IyzA;eMNIbb(hbIGySHpA#d+!`yF=AA0Bv z6MKl<5NH}oF(d7uwm=6-NHa@iV3#WFLNKaNR#)#lB_*dw@_)Pf=URhW$ZdN{cI40V z?kE)&>o0B@)^&rWaP8pyj9+2+gM>dUr_Sulbbk3Hvbi(0JQ@LzhS4NN*`dm!H$^hV zydO3JqS2j|c3=`Ql|6+S1h~sr(7fX{m7l|{r{DQoo<-Uz5^<>X;N$a;czE3_a)Uu? z)6?%0fj-qO851OPn3fAIKFNDGI9iq}n9|tVmYmTCCZp{$&$RvPY{TB8*6HHuqHklA zPh%F!n0+6Mm#~}p|4|Je8I%(L0;!Zv@jN`)E z>W{FEB;GR?gvK|wE?IFcFOS$-xttDc@F1^k7yE$=1>1)QFdCIj?!yGoEncf*2=Cdd z1!?715kYA0VO$puPwnNh{2GUQNrgBsY@vAb5VV7yKO1ZlL5QO0aXxNGMz&g5%@F-n za^IyuPVo9+k(~L4X{XtGGM=wKTK`7I-q^ZYe_sgJ!`9+4;{2GGg5Kg=^Ws{4pYghT z-qL?!n=u9Q$In7^fBOM?`&YR^P!n&7xogwhitDC@!#T%8Pf%rC-|cTHw(T(TOyN}6 zIfX!BUB_cJmkZDvaJA zqUUpRI|wGoP9^H_Z~%&F*3hxhlPr#eYiChf`H9buxaEYWp;EM+C7~bGM79F}P0n&i z!5Fu!%vAR^pX#69S!w4x3CT(prS*?iK`iLbGEs$Ea#j*0?>{>GR2B0!<6kLwza$4$ z$I{T9wdPWNtqq$0Fnp?xIh;vpD<`gBZPJ0sv$>3mw@A%(mm%^jaL;+|6y?HK&n-(aUf5Ie__kH@_IPTi{f>7BOJ zpTYke)c0>{w}e|~9V?i}_@cq-MdQcG!*F};KczA4jVuXK^uu|Dynb{14HC9YB$6_J z)B94YAtvuc#nQbI5XcP#Q3@N!JNj8V{s=a2u=&dj23we=?!NCd*!^x>?BP+)iZ4pq zg2&0z_&M75YP|2TwaKOh*8HYe{LT6e~X7=ahHLOS@iJ*tLFcE(cu+dvcZ4{|(2V&^T4hOa`Q4 z7MpnygxwD7A4AsiLk1MD+UP;&p=ZU_@dG6gWk;yL8=bp1KE|TsEi>v|8MVJ<)q-9B zHj}u8>$k{$1`(ewvFdk4C>4TD6#>YrnvgJHxgq@q`WS0^04MM!BsRT|t(%*7cq!ms z&|tQRS7_=Cc-t_B*VQG11wgCIb!M+r`Re4zO7q-;<3LJtdN(n0D+VO2{yO`q(JP1w zF|P+!7Sr`0`ULsl>M|r+tMv)3ERfhdH{ZY)EiB)f&pvhrz!7*fyz+)KfF-`oct_k^ zY9X1>2eSbTWym@wIIJbCX5P4;n;RVc+qWVCHM)m|ULHKyd#s)Ft5au;D0g1BtUDhLT1lzL?mOrRsO?UMU-NM<2~S0( z=rKWB@&;!ytuu3{80hV#*r^cEQ;ZuNaAj%6m4V~w!i{H zixR-&*kb68&jj(2o2ly5?*EP(%44w)3)RXi7F1=VwGoo@TBVsn7==G5qQD4tO zv)MZ3ACePhKfWFR!LyFu)I>%q1`9KZ1Y8?8y}ehkM-s_IO4XBJ_s7Yj?gsE0mK)nA zoDA7=fDyIw8=XdGgXS%?X20iCpG62LDFxz#)JYg4E4S;)FZ{7GYv}lnI;EgBHxaVN z_4s&vXW#E_9o{FbtUPPc%GvR2+)de>+T6KF>^V zF(z7m&lF35MEtm}F$F@5EWe4BwZ3NCtU9l-0hB-8JtvIG8mE2^ZrvX>EWR)<8k1sB z*U?T-qym>*r@(sy;-Dva$!cp?xN{%=r9bf^veL`P@bW~?btXa!oU&Q7a%Xl%WYFdk zk4n#3=+$7iO1bprClKFTgN&q*vLV_651N}(zhOA!L7W#mJiK;KMS-@&^p{%7wKlS+ z+-!^QuJl{eV~bUMR=Gj#jRd&a>SXv&OzDll0NKaA@R@+8{TAMycmOj6@dV)x_eZd!m7=2~@raVaJ^bD=^CP`=%X@?-l4{C#ndn7-mW`N zt8qsKtxSwE@lEO7ZB}iURHpSE)06{m@2zSxYhHi z+f~>w0H5)V?&&2=On{UtQGV^beiUz-S_>`bUnH{=`L;IuA6D+0X5=H-YP$hu$Q z<&{b0Eheu3Lc>Wlo;rbcg!#x~>u*hfLI4)lVf)69^p!|Z;V-4!o;b+B+-bS<%_CH1 z;lL$B0xeRBH?I767$MZTkCpd&g%7ggCcLd2-`vc91X=WvREafqd>>cd7u-|cB|Qo& z55)H?4JiTedpkhMtRbqsSNRAAni}zSeE2DZ?n_tK-bvDrFDKr{wozYdE&0LlYe&nR zh|+@Y@z$FU8m@X$SZk2{ZZ0jN>QJt|19LYfWn)JztzCUcbFA=}iG=mSElsO;W2za$ zaL~zC_$Sx3-345;W%`8We`N@UY;pPaIE-nI3{kbA_{}UoSz_)jCwe2;dK0bg;*uI7234vL+JD@xQBLlah4X_xmohSlimJp;t-Qaqz*L z+BKR_S~fM*gxxSedcjH^zwiEPETP}|$&!%7S?yR93drzx!bqVS+lS-YOhTdnmOzE@-mK*O(R9#lAm zdAWo(vALsl|j;-%)z#Ku)!Y`M<4SMLU=c*W~kIa(~5=z7;T>~U?tagtL zC(6fr_o4xa@`WxM{-a5m6tF)jFPOizEGkT|u!g*U8?tpnMQcg&ZHk2=bUwA8;(cv0byzvIzl_T1`F$jf&>wdXj1)bk;QU(e{@5-ZQpUtItx z!ZA~+JeA?M_(+9F6+nj}?}L^veoP0i>-t=7Qs(s7nS{iQ&Ara+_=b}doe2X5pJ6l3 zXuK7He_~TI44|5}chhTmR9I9+yax{MW3KhBa#b(kgPnp)bm`}PVGq|Z@IOso4*-T^a|c>De>^wijS}YQ1ecW?9@~_&e@UD z(g$%RLkiX!dIrU)71pce|Ha(W1KS^31AxcJQgQ)3=Ks(AGZ&Z9qaPk~f_Noz{#WKA zoGNoF2=elc`z?wm0T$+*$Cuv(&&ZT4^f#jhLDr_1LNG-&=iI3}3w+(t22&lRDW4&J z8&Fq7^Qt3{^L4~guWc{Z-z|L>LffN^gc?AQvkG9fb!V`>4V}sos06*&S-mLFSm!zv1Sv2+*Uf;!jrm_5`k2Z<;)i1r>!RgRdE}^UYt0+C11S*S;c)gh`mCOoubvzr<))gdah6#w4>@~+?im) z%2~qUm`xtbeL*Dj4;O3=Dtky#?9i*c*R8BOskl-P`oH%AX!hyl;V^)BDteH~OI+`( zg=~W$HMLk%r^CLIVwJfztIX9feSlr%2E3p`{I}HQG6#xc-`+7SVV{OZ!#oD-c@A`x z5&I-M`mUdzjA|IELSRV=>5A6$LP!FjeuCR~y-uwn`o)n>nssx#9O2=tzc zxE2D(yEHUTMJVM41EOoR#{{T1id!OWW@pn7?uu`&fC7#=2>SBHcE_Ta*<7f;fdnvN zOv*bK*WnE`L+$#vs+XO_7O8?BJv5X$wzpu#Wz2BuB1urgG&YrAW}%-0QC9xrS(5G%UBH`b9X7kF-_aKe(gxk{C&a?RGtruK)Of?cI(Ms3 z6gVT$x7>Te*|O?dN;&%G;a6!nWbxbG1xwBKSv04F*pELUvy*t?L?Oj`I$Wn$xj`4h{N&%@1LXTe7IX---lo||-i%r5X=0lsjlu8Rwg z$Ux&;q;?pJ>q_d@%{Pv5o+V?N{}ia22nqsYq7V=KICedZf!1WdCc}@0mxkiKYH)zK z^_f2lz$LLcNr9N$gOWJY;{a-SQ0esK^XF`~6g?glpGhRZzkYTg*=uxdK;5W?|D_-0 z^MzfcHZg5#9JJ7&E2rm_ugFaK5GaHwLmn{+>b+U^s*oetl_vnX)6^Z0i&)VdSyDc@ zN%YnXQGd$yM*ucXn{uwRnE^~J5DER>`04dz58r%$YT>Kr0|3E_?BQ;m2nuU*J9B1@ z%l~0J4N9I5`7a;wF7z?+V9FbpYfi3IEr=+c9_Eg@3FASIZz>9qGMjZd4xXwWudw`! z35bt)05zAf>hk#*Ko|keZS>lzg&(mnS>;nJt*Xx$P5Yz?SP22MG3P<|5`kS9-qkFmrokszMhCgqHYAl^;M`W$RKJFQxM zcAd^30gDD|=0SUS_}zBqSBahilnRx<~nV84cs z$MNhW6Br4M`sx<2=xLvQdw1Z=VQ{-^;b$BF0>Ft0&*zREKZH(^dpkV;9imh=QIDSX zwcZ&Hln^gjUJ$FxcHE`2pmd4E^2KrA&Lzg(kNK3A>qP0rF{$%NJ2C91P=I%yKLm0U zLUb|^DCFm{)pvA!+zdgp1VPl)G+3@o9NKwdVWAGlmCD23!==k60&2vR?`3Ja(%F@C zbObkhIYk|T@pe&goFH*>0}T1%_v2S_heJ%t@FU=&qA8NxD6HSX;1YZ1P8jxUc| zB&t|58bd$+Er%mL%3QO;n zbmu)^U#;pDe}D_P4-^o3J!|5#Nif^g|3zJ`o?pU9F@gD8Rz>yhIqGiXP!o=@pxX(W zX#z1aQNb(lW5O~*iW#8jG;DqI9h;l4cGtMh1i*(qV_hYN$HbIsC-{$nR3iB`fc3~P zKf1ily!EA04v9g!Ua7k4C}#IDJRF5IXcO57R^7stwK|K|TU~Ga>GVjL>`Ai$J`3G2 zv%wcIdB&~MHN>adYp1{ue)`Vxx!knO?c0tQSQ%D)Pp(zg2s@~oh7W0Ftu0rD10EJo z49jre)4|YMQ1RM_0)v=@bk~>y=T)h~bBfP9LjMIE4PU zXS%=SkQDmKg)Xdw&wc1gt_A^-cV}w*7%?-a-*8|iVPPz=5M_4s zUK}_N$fnH7N}lO8ulvCn%6PRa#M<+Irhq@P@cOeW}BEMYs(6eXe zQ?zzk;3)cd<5Et6Z?TwTLK^r$zPZ)SzIY_TRQCG+%q#=F-C5Vc-Ee z9dw9OlktzPi<40uv)&mA>FzVZPHig?rDML2LG}vS+sj@XuUa`2*j1{Zid6f6!FoC} z`8atk)CV1Vo=lJ=c-N9j<)_NNlMuf&--qUKB}Trg5fKm{1q0@;8ZUVNuqJw){b}7n zgh@KboDt*A50zX|TRFb`DoXl`#zhUR90hwiABn6&y9{H}#X!XesY0c#3y)X-3%T1% z@l*(Kh-;_|`&=WFE+2_Ko!(6FX?FYM086mWO$ zARf=?Sde%AM8w*$1L`3mj51+)*^`{h>&}y|cQ~C1Q346J*r0NhEHf{>5j&=fCmbxS zW2;sZE8o-}E@i(?dw!J@sBPQZIY^v7lBlfs{B=k~&v68i+3D7e)yY(9Nzxi0@jcfu z&JC1O*Q_vdPBfp)fIlKdYeNB#!OBwSGs+eq$eoasxfvv?9tis`JD?(?eO50K1%BEY z^ZTZW{KqLd9|H*zAs6m2<3{%1hEmRQ6GIdIKzi;o04^uVUc&bjHM5?|Us%HqRZIZt zCNViuZnN(JhayJNlL|f)Cwgh2wt-~4DUVkhuoYD%w`dLcG8&shJG{k_@dVlWp2XM>ob2Y!dWU4|o#S#*- zfq|e%l*+G9kiV!+G-5q{8^Bv#y}Ff0w(8&T&awgCu3W?I=>nbzvl?`=7-;S#2sE*e zWE2(Cm5#KQw}lm{9KLsS7~&UgLH}GOg3x6=DsYct#6>4*BvA_t3Jd^3E?-5wr8^xJ zTETycgL^^4{?ZgY2;>mFq!A1#^tO z9>8AHN1TL^KzxzpOJ!@9{ecHkry;TN9t~Sl0H{xz14eFz>4#W**Bb8ojQh_H^5lIZ z3v&2`F4O-C`k5{f9+eCk4Di(R!k0u$#_k~^e&}$(2y;P${VX&uoP{2I#Yu5Om*M{| z=@#LEFo5C!n$*~dJBxGOpd@Ru?mmX-k!1j7p*CS%R7SG}24MT+v9#3|^ozt~*FPmH z*Ps2HD^X9sSbm-2wgMfH71-TW5eQ6-&vQj%e1}^I0bTI&7|@fAuD*mTOdH{4@2~La z3Vo8&$e)n=Hv@^`91IyTM)XQzj&4;;XC_ z75PTtfNFNvM#)c8IAPcDey2eA`Gy*%*z%}ghlceheON<+S%WG+HU%^vo@NA0q=Y#F2{U0Gfh`TXWGW`_Ce%)Zw_Ib*vt)rs=; zp6uR&5)w?f-OE&H!fdW1 zM6GbI+`O1!a%D_LMy9-U_t4eJ!<93jfCdy3fGV@H&f=%74Dp*;X| zAM%{!gNq>lk(aP+H--u3%Vu?|ai|_y5HBxBp5e{mTQ<~DQbVBAMk@oo2)GrPn+SHb zs*JO^)d)As6o0;T{TP57{-%U>R~Ne$c)A`|#*=Q7NX$oE%%(n$M{nD%6@Dg**18R( z=m2X3#8OB5=)WU5G7cM(!XC-`&EtA{lNM-2AI|O8D8b)1{pmp+^S2|P zGbN)TWC(+}QXC$R)K?0Vko+YHBp_y~n;D`~`p|e4$fa8IvjHN5mp)vJYy-YJ4wiJp zkE0dA+F)J=IIQ@bBzXNB8mZU>dJLQu0-JFBxF$5j4>Msp*$cN$%m)O~Ni*8sl5H-^ErJdIL$w~*wIS&6h zkosUtrW%Hu+h>2yF1}9KoUKAlWwn7CFsKE=DF`BW&l?|)T?G=tIzTq&3ZHyXRR!jcC<1oBWY13}*kl|2-@V$v zy}n65IiolJ;)Ueh5KNac;dK3V{T}~1>~}LAD=s32ZQW-<9?{QJzXK4zCmCaV9H3{r z=sHyGt3bvV4dAR#CYG!;_%S#D=(%&bf>}!Ox2ThRb8lct|AS(-ug9Rqfo9LJ;3$1vI^Wy>Y8mN&)@=CEOAr)_>Z3^Ju6x68?4l{9z@m0r>MR|5HMwa1?#D z{4)2RgtFRt3%YvyD))MkOdV7ODQkHH}se3E7N3>et}*(m@=4oce^c36I_ zzT_m~Xp|8mNISGi=P83*e|S zRPyr$qk-_Zts>4{cvHU*J&t?6rU0-e!tSwm7$;t&of~AZXCYl*@%E@t>q?U5AWF$tA(|3zl#ppmUn#)zl2yvb$R2i5b#&`l5jJkdLt6*N1L~8D#D$M7jkejcY1b{qeX%%A*oU3I&qEN3Upj zvWE&G~KTo)0ZcfG59);>Kik1A)jb$I>@wduKG93`dVQoz$*gu#lDaa{9zZ1WEV5nF#tVdjM@z z6&*p>itB6g{@Gz+^LeEW*OSbG{u9){l@I5#=PYQJxspP_nBx0bZm*RZ;vmHg$EJxa zEtt}3oO;z}v7SoC;z`3bcV#u|(e90(S#DuHjKWMnV*Mgwfa++HMcvE_6s}OqhfPsf zb@kghJ~ZfkU90KAz>P(qoxGy%8nsmlP%?wEcwPwtRU6SmKxY>0>+E6rd8M?Ji7Ozs z;f&I?!`zT7nsBWW0BnF{hMy4Ece|=;-j_>;Ke72Z4WLhfLh{kit!Gfg3ZnSFndo2O zEZ!t$8bTS9e(#tB0$QM!B-VK}SY-deO+cN0SoKB|yPX2`fU?R3?a9OyzP0f{p#LtE zaRwPIU`7JSVa_@!StT9>xM;#du4nc}cV7FgJO+Zr0tZ~Muh<k6)>b!^QG)oqQe#aVt27)5s#NK630RD+JB4o@jO#T5jt@a#33(V z-#xkcZ=P!|H8G9yV*{`1(L{al_2$TP|=tg!EMH{nz%9!l-NXpw)cwVs=}&2m?W*I7DXxS+%ggt zlj-{;Z!xgEa=21-V78k}OE8hz_5fNb7i2 z&6mbKsFYhY#hX8X-*UQ*WPi3msY`s0Dbgrm-g$mbi!fg_si)hsWtuC!Yo)lFobZC} zV8q+Xv0%k&!9ti>X4B){|G;o9O?erl&-E^T?ECtXsoS%&CWJ9hcK?$mas=Fpzvs#> zZmu4l-#R2E1>K5|_t;1UDH>XT1jKYAL(r-2AONS~cPX(A6O2J;vu&u-uy~j&Qw4 z?+&)lLUVBx7{{W0_}1aO6T#PtLb>}ljls||TqFPF@;{=l^SlA3;m@q7~flFQ9LO3tXS9m`v{<|FNRpdFLND!kbs7OL1H0*Bb1i~U~y?&h! zJ#8}Iw>DZ((;UIe*L;T)TAG=u`mbk!_?!ls%%Y+@lXBqEqN?ncE4A%C z!NU3(ZU&L@p{;{uMik>!jaIPlr0XMU0F@suSvag(vF`3{P3Y*1FAu0K_7pAeUO+?f zoq)aoO)$UT^oi$I`wRexz8razCfS_GBF#HYIad5`h})bp>F%Bq;Qgp1Oi%JAp3ubQ zhl>9Ci?A&sxvQL&lS~x9?~Dj-h$>qG($CH1<#-O@qtK^_8CK-HdLZGO2@P=%bI#Ea zF00>-Hfrb=Yv&}9jgIC+@4W*+i38duj~wn)JXx^k4Mx{#Ns&0C=sH%rzsYTP zqZf=P68ViYK-s_FN2IeGzJ!?EKUgrO0m7A|t~Tc3s%b8(q$35Gt72FQkO9Qw68UgU zJ-mXatq&KqHq6QXj<%y%Da1++>3?oSd%XpUrYn&Os;j$G=ZqOVV9E&6br|L8n*>6G`Xkhe9-^#x%#pI^cKSz{pGcC=f2{X1BllVTYcMH9PwSBiMuh*?4T}}rXxr-d#+Bx^8Dg>ro3(cq4#eHOk4R#KC z&%do)mUl-2dBiGiBQYB>Iq!L>E4Nyd?GL5YM63K*kl^&P9LQ4^8ydb<5x_LnBHnLv3Y$E z)jz3@p-jw&go_KXx=7|$(&-2)#NuK;31;gfv$-IU+3^A;Q&%O<-%A3=eDnWj&vLWr zc~k)CJt|z8eX@@2yv&BY@0-;a6TyJ#bI*#Z8H}%~4AJbH{QZ>@yq?{0dG{~(7L5WL z=@077m5ACQUB}Pw$L6|$Rwe{)WZWGiNPFG6b1xHjxo@ioOqCrWVo_|_wiGB%`QR=8 zAg8=z2rn<<1PG8HQYJlK#@`Qcmg`1~6HhT+Lx}5=nd>27khRKxokLPs`BJ)HWMQ$} zv~W4^2$YHaV9rx51RMtkUXzoD*ah={ASFM{Bl=DhTi3W1SOW;_+h@V_T|Fy1Y0;P9 zM|ot20D*c_doV&Rv$23-fZOJZZG(YMA@ZmqJF!JUq+yN}d1sJNuk}f0fG|Bfqi3)` zx-(cCh?aU-CvjA?^nOd#@aHWzTtIQ}PS8y}A?J>^-?S)*=m{hMx$IwW=J8p+NVDHZ z6v%*|^WEcC=@kyFB!Gm{m6Zq_>g&5Py)2y^Np{%sQkZW43n_W==LE9Dh4jB3s-FJR z;RKMm5-Z0B(4g`$MAXK|*NOtz8xZ3ShX-q5JQ28$^5Y>Ta2H+h8${0Ko-c4ozHLH8 zGSYqtAyfwag5dD*!~gBp^_@Xs+iTeETBsSJ)Fi^jTHD>f6%c8 z#xs(CiUMaSA<49}AHC#=zurK7P_(JH7kSrNwpQ(cik_FwJPhB-*o(nrE-~LTCX^mtrMYm=cpF;{N;>AFWY0=Ts2wY~%kz6bF@Bo)Y z0-Gkv=6u%g?$O$})!tA2@1Vkfz>tFWRLW-SY4H0WQgV$U>Ew{6rfd&5=lU*S2m$se zIqquqH#ViaNN$LJlOBO&P6Vgt!h2?qOZZZ%MkADkl% zpxKX4`p}E{Sg| zz!y*11>@Rdqa0l-<8f?9&QG7iPrWG@Joeos<%|jnqiFlbWN+`vMKp~!^{e1`(u&-p zsefR-$DA@5R3!FDQjVQE3YomZ)}Hzp(HTh86X=!(i8VpE>TGW*iFKh zA5;agCrDa-iBVwgVLQA>9Htdf{X5qRROxcX+5M{O>7Hf1c@<#b?A%e^2LFU{_n>OGYoLIZ1pPot130{w?}6#pk~XvCTwpd(Y3s3-xv8^!+{8(XR1i%U?IGIWrcIkSWC zUs_q(a7q|%)=y3CC|C3u>fhdWf%l{{hQe%KCfB!$H6E^_^)Iz@df9p9Q z4Qf;<|8MAkm6Hf+rcj>7oTn5Cvd>a4C8@=pI!w{P&nG|iEiuOg|G*3W!Ctni_i5GD zSCvA4rlo}j2U*TOAJ{v4tMSC1*Q)0dY5ey6g;3xxhw*C#*du1z zLT{&oUlxK{&9uS!_GoW=^Im0ol;OO=x*!-RiN(c2jcg2mbQG@6h8hoZG34erVgJO%R`q{Y`xzid zGijqhrh~eS$#ilc{K(N}1%Y3o|5!w=pe1*Yv1XbUz|R;JKYF8Xg$|ebBqhyxXI7^N z(kROfE*Yng4lbgwl&)8?7JquFNIcEPeoXFo6i|Bz5TUa5arS6XWGIGsEz&{xRFPCE z`qS=$B$)Ezuh0~zKTxMLYF1ln^-92ezkPy?<-qtR0!PXn^{Ak1ecAq1Zy$TJ&qRHU z0If0sbic~;2C|TFrelkyJ-VrFdBMVcJ><&K%VA1~i0%V0*k{<4n<@5Fjb zB;`E9*TMTOxoM>&&0&JPcaPBX8O{%c1_-(Pcu@lUvAPsqrFay(n$bEV)KFbdh$?aG zt+;FrK|DM1zkrB(LIeT@xR0jQLSF2t66nPMh2rc}MVCOA{#@LuQbwSDiV*TkomD0{ zgc1=kn66QiCXHQ<8JR^q93d8;hti4J2*wQ8Po#zUbW|7AP=93uiF6}s5!wh?)4l(b z@-HRBZ(kW~RL*>I+d1sn8uN(){lxEE&n!Hs4x6R*@iXt{oVRWwj!s)p84 zUxY_tn1OiT#-v_Gl=~d>uOT1vl}bXkhbm9m4_&e0}iI;IZ!1Luo)%?6PM%cYv=Iy$UepIK@&qml1Rty1~9 zTYA?0f;kXvyT8c?zK7KP(4)G^VWI^`G~sPNPTn;*bGuY2!Hzl) zwW+6K{It-5M^6Jup~FO_emQ!f$w4B{aq6T`3G#hALsBbo{RU+H@p8QbMP@~b6qWnG zl9VQMl;V|ooya5wiC^TL?i|X;N54s{nNEyoHdp8TQ75-pgprFtt%eq~5#k)_!ECrB zTdj9Hl&&?SPi&Bur>Unb7SgIBa)h7E0y(Ao+-ned-3zba{aK=`A6vpjL8RF)Qev=l zGkj$9d4}NtcZX_`>iOXF5ZGRb>7Y^jonNJ_$Wfihgx zm^?Dl|%n5OyDX?zIXY;3+ z1vsE}5E&aX_ympFyh1hZj_>@oM^kN}qxz7$tocO583fIDp2D5^i278j2;^dMA{p*G z@uo>x_N~dBNcmIWABnVh6mxFT=0Y+JLQyM8O7WvT#5+oF(uVuw`h!A3J&=EZu*-&ePMFONF3P>s%aJVgAz&bo^uVb{mp%ODLm&npj3u^WhDBmN6~r z+*UYZaPO7m&r|hibtdxwlgPPdI?Jt7)|aXLKBmED4A1#}-UoBnd0$dySY%3ny2k5S zbfK!5tfFS+<1uI_Eyn>fw86`H{jUmC_CL7+dWshJ0jdwD_f(l{d|^6^#Z|B69JNEh zTq2v^c=9UKlUr5uNvmilPIN)6FAZs8g-}| zH{U2Am$+u<>OSe56Yi+&+(GB}K9P&+k-Y{9#jWE{BI@dGxplUQ0T)au(`a}|y_(8` zDCAizAtsCn>|D_@;69}S`%C{UhL8Psao`23Xj9V!G;oA2DW=Z9AiTm%*e+)$|8vrny~bQ0MWkioc`U=Ur%TDLVz|Znyo8vdxlQHOtYN;fD6g zu3^s*w*L0s@kTcYEA~b*n3~t3$@KqVV$+7|0Hx0jM$BK+S)+lGong2RljQy@Dl{Bi z=sLnqFaVQ>RgezzsU5z+38N-*ogUR@COv;(QMdn^l`cQUUn(IlwWmTYwgGgcjk<~P zNhppeDq1%VsZ8jDCbNtuy|SZcqMhKFnB%8IyO8{Lf+a(=hG;i#p?DKFMoF+S<{V0% zp6Gm8ro~?aAPqt-l=IevqR_&Q#!H3ULO|6=%n;BmkI|sQ1fFO;q5e#hmmu#OZj&BPH*GY*O^&k_@xH=14 zHLICf^uytnr4Es>*)Zp{LG_Dl03{fsRhn9C>1hVl7^CNJ&U$(EeB*$D!$dZFiGX0! z7uGV%JJIbF7$&@Mn?bZ|XUxHwZS5b=L$Q)ko!t@-Sl$h$l*SM+J>g( zDofk5v2r5Rwdr5ViHUbhbkNb@8E@dMN}daNnC6->6fVP6k!7x> zyx?xF4$REhB`fv|iWFECWYM-6e$+L@tS;9Rlj4BP6OD45&O$wNs!oeim9sIT7(4e7 z{*B5@r}G{fl-MzsQ^il=NIfQ_ITE-8ni!S82jDKPn$A8GS*)a_Ex|%2Y#D zHF_#;d!`iiJE8tE`y_|$YC6g?fSffleK?h^&4BaIxVvvSG3lY{`_^zpUU4u3pmn)+ z*9F4N7he#%a#RWgh6P?^-p9PEN!n@&}c2=z4h=o;L*0lwA(J*Xp*Q#%{$N zA06(!71nGyIwV0*XL(tq8aP7%I5@~^k%20niNU9ef!g$A#(|kYlPoa!rV|}nUTIQ> z-ZOxD3p|KSjt|{aWn+&6`vy zNl_ucC*GQ~*?IT*dpG-g&#$;cW1XFaBKi&K`+pQ>JP3D3W4hPa`ics-+4!_*^ccv} z3$5oO=rCTdR_#qX9t>%}ncAPM{nLhsN}XpwjPp$sHF@U7^NMyZ;WRz_Zy|xsr{195 z3~4O#Tv#}J_U84ym6yrmt5TrLG6&UI5fSryoeQ?jtl9cx;`}Z6;E>>fQ(p`E%Dz_t zO{RG8!cr3{Ras@~?%$2%vt$|Hn)4M(>dK&S7in;M*zH=pF9>HTxgp+B;1rrih~!@l zxuAv)*@7gpe#i95uwF$aj?O5gQj(SUMXFNJhN}1LSrWpz`uaHXBw;ds-u?u9HTI*@&e3nyw{e3XyI)B)5E&*7Vl0F|IuoMFGy~akL zY%7T@XEa6e^?ka|hU%(#Ghx`0j7T^--|B}Em=ZF-w&FJ-8=#nC@xL4vaMm$D8KFVJ z8g*ISVZDtTalSjJL5Uj!(xc4kWN8^WRi{9J0hemMAV2QD*JN8r(WXgotb50N8VcX`b;hRw+*QOChwVUX4v1D1W-EEcAe^dS5Ypbuu zJ6yt==Y)C-;v$=yV)37$5WUrc|HAwfSWnA`zqng%Z>#&IIgz>UW+ zBQOhup1uT2(@X@K(!E52RLH3O`|;K740|~0mSw|z#{D>&ZXw0okAK*HM#*Vu*`#uT zPhML)ak-M~ywwn);(+;gxtbqrpobNFP!&7D9SC4Zt8Cwh5>Uj5Yv$+|fzLi5Y4n$#FT13=g2 z2m=|Su;jaViHUyXR5xHQjWQ?lS^byLJRAs+T4Cje<1O4bV5+C8M_JW7e^8~xT(r8|%StUs0 z-KJwFGBs$$p-!E*)2-e2jHl)A`xM&nl@!(Q0> zjpq|7u~SRW7`6l_MD{+yPyDpR5O*Udxl`yzw{IS_Xx0uw!q*E!t}}1Z_}fN9)u_3? zS%wtw?=M>W{Xg8Fzg+${fgt)PXrz{eI}0O6{O#qlLy)3s`C=E-wiw(mGH+em!|)!LoE zr)e|_4eiMHEyphdo@`(gN~wT{OG0=5wyq8<4l*@x!53Yf3{mQ z;kn)0Vy_K&zV~buXSfG=GZW#%(~%Sci|DLS$o`s8B2D8n=MU;Mv9U>uqY9QU(0!J9Wpm#Iw~9Iw(%#$(0bd2VAJ zwwRGt{jm6Spzpi8E4R)swi~%j!1|;+UV^#@2lED#es3w*#{q1tTW!e4Hwti}vE3fy)Rl2a&($FmlX#F_R1<3^ z0tEShpbethGJcJuHoL5ywHx7X;Nq`s+4ju|PDqxE;`1Ot5k~(-{Z85t`-wDz1SL=y z$$7W=5n)Q`ev;|kBBed0*YPYFJ4O1|$Ov9AWuk1KY)`!{5GdJF06Hpw7uh&YP<6^Y z>z`gHifG1~Q_QYeW36hoXQ}$(j4|_00JvHcQ_mQ1U8#(sE2(JTpEJ;0;D)JvI6@49 zBTd{@uJ)awdQrG!;NA<*e(-rK(kj+0daZeqX>02gW&v5Pn&%OF1_ySP?Hk@!)!Bi; zFx*o|_U~+>5rVh+7{JNf)Zt4iT>85pFpygF^6-ZZhOZ}f0{LHrpVoaVSNTM*ZhlD% zYI|QnAO@jX$2;;2J0t@fB9pzbCk_oUR~!QKqxj>ws~Kr3uIp~!Z9CUZ;YcNfb`v7X zXnHkdUXMbZ!l%kVa<;byd?#=1Lv#wtxH>mrX#HduQOW@*ZV*Cb_?@w1YssW zA$OT8~9W$VR(t?k04NNVHiw}eAl3I$@TlW{jdOlPBhPJ#3MGE(_OS6Ur3%_ z10&+CUx@R8H&FerwdN!tkf-o_DuA)nt2|ghvUB0@Fm=F ztF@CF^ZP!dq6}$UuY!)($P9-GN(=*7Zk)XHqra_FK|J?&Nu*OD+|ui$^Hsm{OBb+} z7*Wz>2xaEc>D!D8_`p%6Do1SM0D9q+nfyNVRE&B{fL16iNB_3jd4=(6r9RZ~DID3S zJA|VX%{&ONYoNtXpnpD}(wB`K{qZ4~m2WA2_0v)}nW(_H#yHvbLL6n6-tfeRD=XXe z2f{nmdpK|^1Y;zE&Ol>?R7?BcOC37sPKM#Rb|EYc*iXjzN$YKEQt}z{$XMoKkYR_= z5Xj?vnBX-fL5=vHs`U)6&pE=v^xTtSm(qETYohzNESMMAZk|q8_Rnh*l;j)5p;IFx zTPH%{0F>RTI7fMk3ody{^&SAA3~ES==yYv|xgRGU`whaEmkBgBgj*lR4i>#P2ru7p zO3)m}D|)N4nku2;&wptV%|s%w@&4+G$$@NUuZipAAHs4K?Xr3dmAtoU|2NKl4B#+9 z_LPl*wW8V6{C;UHi1vDqKsGx-CoUc_#N^Q7@QhrF5hij)aCF}mD`h21B-06N< ztwHJ1X}m(e*|Z8!k7#{w2oXGgJ`*{%cj!p9 z)qL(o*96OSeiu07vFx+*%)s>zQIc6(j~TM9fArBC@*eH+%Sc(@S{Mfvlzg99@5P*|qLq09hj-$$a zO`F6ShQjrCPNegat*v#dfvIxo_0LN~$<-e$OZON7#ddk$>c*TBVl~T9tBr-ir93|k z=0btdRK&6%A|3#{{~36=A@^^#ysm#i&(753j0KCA;K7p4FDY7ke`zJl!)F1t1+r5Z z6}@4Q)btGw!DQIpl4R@JA-O@lZ~D^fuz{i_7tdp3Z$i~N?|n7zZ?Dc1cugWgf+VQX z;n|?rp3ZLs$9|i$x0K%eTh@33Hydc2`LUPA#G4P->^G^Hl=&1hCDXYcv(lHOCrbBZ za&$1&cff#hOcP&)Y^hRiF-5V>`2LY(;@5RcP zaC#jmLEm%aJs&xu1@D1u0_Z}&Drfbf#pAf-w$k{hQamiYmOnO_gXG`WmX3(*VNLqe z!s*9hVe$1yqWgPd4?A+>eI0C_;WBQ4ttT30(9^T+!o=$yC(i}HF$DQQWL=rB;d<30 z_DO1Y`F%a1)s8b%j!mv8+DF8u3u7iuIgE6SH?!(_SI=>qziZuwk<4@{c)M98xncW2 zq2{}CzR-)(>%*isUa()R<42<1BY*L9WQ#X?{(zN}Dq?fjqYDBxOC;0tUjntQoyjBt z3{!SO@h))N;}9r+?ITi#6sH3BhxU%z>5d7Mmoyc{21r3@T}-&HY%Ly`Q%h+kV3zGC zOQAX#?5%#EuCL)6g4^KUhGUhWrvcrRaOVCW2{<#PK2?G`p69@B<{Yt)Zdibdc%|~~6)I8uYsHT4D4#bg(`JwI{C;a-R`CuLm93KaV z788txQsiS(WYT{`qQCV5am#Xt1_Yqg$Ij9DUs(nlDiG|5V|);@a~FAQFGJS8m#I|qX+^WktUo$9#()}C{ zw~XGlrg-O~x5u#7pSbp(;=Ya8XYyq?Ldr6PTj+7<6}PLJW00GmvSQnlVx5<7(FTm) z9U_>OL$P^%xyt4c!TdaMJ5xEL`_2ZN-tZD{q}uj*PYJg)pQSRX%f)HZBhyhv#i2<8 zn=d<>KI8!xK*Yx5BHz<0?-*p)%-0F`jR(BpBfJTMFOa5JEkg{FZLj26-fuq<*)_Z7 zksnKhE{s@_3FJj;(iMz66NML0W_kXMFTAUZBCX0XHg2V~g9KyuLPBtCqnE{`iW*p9 z@xODYNU25##1gv>X@RYNzJs}n7w7GMfC-XeH1&Tfse!D%YA!D=#avAKqo+Wmch_ke z3=#mo9?;`0?W0X_CS1CClH4rJ_&>muA5DJ4I=EWsY1G-D?_vJRF!|FMxiFBr9~qM#hEJ5k zt|CK!%17CLeM=`+_Zwxp27Z-Gz?khhdi^oOm4~cKMLozs6yuB&c_>~uZ)56vt=6|R zU;jXBP`un|lA?QTH{8{rnv~MJ7qVj;JsYx$j!b3Or9!1XcP3YGbPQv|2cD|inqXMQ zwa{6V^eGbMj5}wn+PFG67Q7SmEeLL^NMg1RA@ksD6iWmdp%anG*7=ryzCBtTQ__xe z-d56=y(sBA$lF95(Z# z|EGE-TFw!_m_eK}uwB`1AVa+$*W|leU&bE)(6--xXz}EFl}??ZB*w((dEE$n zR#{zq%!hG{piYT=NNiV3%ino{h;4y$54wR8Gogz`x!CM!y%h*#TChOr9G!I8busJhhg%4+30h)bkQGH?9C_`eQ+O#;G~kaN?2F$ z%WoeIDkF@b)v>zENWJ{%ufc)VGh}%>Z1GCmu*ZK-xdq@_?+gB2;_QsMmGPb-t=bIx z+P6!36k1K-Z;Zvt3mv8`(BFv$DX(f{NsK;Ip>QvH@z#ZnOwDY!5sulc^@M)xv!4&# ztuE%Ny#{CqMTwjS{W#@oWk9Ni-~Yi8Q-GMC4aMAs{xW3)>B`VHn|F`p2d($+zD);x zOto`FSa8WdPe(*Eub(HRHnx6Wfj2=l3ECGkG71|!c?VSAhkOf<%1)50%qK`DMJN}@ z0}uXcTLXgtvRjtfkj7)Lx>yatYA=~j3%)_UZ3J*aPR3>oyDqfjlKvjScR)U>Yg}F8 z;m&c`QbYWrA_aQ5m>SHdqM@|AgFU-rJ=a^_>ld9(v%G2$S^l?2zUX&>sBI)5PqQoGjOOi0|hQ^WqxQ(vHPb@iL!u4*7N3ZKceij|KOwp6I*eQ{cg3Tl};*dWzk-3SS*& zlV9sSSAe^2RiRnq6v>ADX|#jYd)jTVUHx4jTI#0tnIvK*2tB2k2PH}cwF+V*FEZpf zrqh7CEFGxw$y`uo8C%ETbP(pxhW3>5K>&<%|Jd%>EdwmT&R2*0q9K`PKBD0x(^DuT z7=3UgKU&-R+V8dR-_m^F$EIk1(0>B`7jP}0_N(5?Epg;ui%8n`d4ad;SRdHTaJ*pz`xU5tE8H25f_zVMbN;Nw^M z{^6}$;gk1tBm{h;ZO;5ZfSo6pTV{v9ilQc+Y%5DgR=M~(#Mv-}iuN0C)$53dz3tK|IH;4*K9dUWZdnm6$Y6i{SU*(_pT)E)=$9|OL zNgWLTSR4sd2_!_V`A9<#<(&T`FSYseTTD5egu)`XL5**^lwg;!Q6_uf23<%gD_{jM zruzNl=-ENi5}e)BeWPb z0%?Y31GEkToK%T#k?4r5Ti-5?QaVt?n+yc;VYWHW?SK~iwElZPxgY1E#_w+72aRz zU9u9E3V10=k=(zs3K+8TShA>aUF8^rC(DR3G|9$!nkwsr_H~FCKO14HGF`=uRdGN8 zHi6z7;=4^J>x2*g=uLH?@GpFj!)G?#=-6{S!+`G!$3I zfWdGEV&dUHAQM# z_zDq-Z*Hg5s$tDdm4MH%&j0O$C2TJv@koO)IsLOf&F3otp1PhpiQqIWCD(ud;8i-j zK5Z~O*U28m7Yy2mu=qPNr|=y3Rf5hEI^zVv;693RnB~I}u(A;YTe=v<96oGHJ;WsY z#T^Xdg3r1y$Xe6a%C?njziSp)L(9yeGfZg|QQw1M#B#PL{!vFL6Y~$9iHhDJ^i3xk zoSexq{UR!DGU@9rs5#zEx8VA<^HRSL~G8Pw3m(X}&HNS&oH6zF7W_nLUgEyC#2k)?r6Iknk-}FX9YOPX$P+ zmsTEgxd%ucQw6iyC-&Nx6E$ZPW{~#aIoif@1gp9K18Kb!X4w8a<2&tB`5j10hm%R%BxU%|v5*a&pC+ ztc;2Gz4_5(vcmY9-gmCq6~dQ8OM-`N9ICagPE=u2^XzZ3WITs!KTfs5 z$4hl~1y=>=WpPu$5r^n3_ef1rl+gV;6L7D$H+RVhL3TtsXj^7mucd8?M-b8aD@2T4 zIjb-uP*M>>xGQ=Mu5b73uC*NR1C>YAQix<^^9L z;FawhDb-lrLcsDgZGAEU`5_CpqHsleaX}c~RY6z)f&6N+6|Ht7hmp-(;Ft#-scI!8 zueM)6{5)LaK?Zg?oTfxC+}GbiO!SxLd)V%rG!|vfny(5O4A|}C!sjZ^JF{d~mZv%e zmSHIeNcv@>oiJ=yVYY#yx8LeN1hI*Z*TRS&^(!eh=7nD@26Q7zO6nrt*3qtGVTt9V z5)`tajtf*xyNYOqzz0?PEvLt8VRBMIBN>D)4~b3sV@)c5xFo-LV|iWbc(8q96?TVQ(h zw-@#cN!@Hku1ucq;;-;`t8PN(19n<|$vsQ%(9Wf*NM`iqe9r#t1!|ZP7qXr1@Z76(i_(A&BWnB?#1v}DPO|m|H<|TJFTOi83#31(IbHB+l{tX0T zhef`j!vlmx_YK>}upCCHlav#kP0ul{ zW<{ozRCv2$v}2B!7~)O=6q4(AhzKYbT%tx)xyQ17ZK-I((}il(LH~DME$w)fGIC+`56 zq;lW*Cyt*e$uY{BJld(t@Nu8Oes*1Q9D5HkT{NX}kR5ODjx~Fd*%C;}{5&&YOiLx9nv`X6Mw_BMX#spE>K0xQk4>SzgJfnjjUR9bExU!(;5wL#N zcK3hyIB^P3dXrAo$r-lX4qa%#s&y~O>S`x&#gKMUpxfFWx_4f@JjhS@@5;k*=h zp7*}bF*+qdDO5V=M5HDw5}<`dHVyxCO1*Vh8N2s9Ty593H#7f+B2=}g$pHD95r~_h zR|ms(>2r@{FaucH?!J7yyw|^ci&VWRTWq4 zf9$5$+=;~oxHzLuBza$7_ohaQH`wo5xN#`u<5V|o)_vEZ{l3~{X;D!(W~N)n@g1=K zoS}p1!@xM5b^5n>pZWXFHk$=4=hDVf`@H0R-}gvUV8+3+t)TN$M}da8w2`m(pA%uf zGpgip#+;uf3`a^!?10E;h6%L1`!yIHseWzBM3oW2$(s!0X>^0Gybj10yq3rp znqc$JVSPSwmiSE$-YkluJs;Tk_d3!~Cn1v8cS>}!=3G!{5z&##M3z#u#rG&LE}04J zj0{7tpPaFEc#uy95;!0J1sCg}&vH%o+RvyQA2$BosBd(%+K)AvG>o+7i~1!4duWKP zE0&iI;!O97uFR!1yC=T!O#~!NrW-gQX$(Uxh)v4Au?l-QVE=Zk2|tPdjx^dYvff6-L~)Qqk_AjmH3s4>mQXS z1UG6^KOc&JSM1^sQ{)}|XU#4*ZW53`FoA!jhATPSzAYQ`gyrWj`%Iw10Xp=?B`Ll4 z*;migFzq8#uOj^?K^-lrrOPmL!l&5HeFYp%pDAZ}+YDVsj@M}n9h+bA#7Ig`ufd7~ zJLr6ni@SW2xzxH=NxtZ|gxI|y+@o<~O|_2lwSjCOlJW_HK!2DxQnIr*$TgW&)bSek z!i*U?J43fX6*{D^pO*D`*DY0xd0V%PfQx5(lzc|z^pNjp17yC5i1xc<1b`9t$U#3N02h?R!wka zA;)~doE>E8a#|dghkB;PtEn3{ZJ!*<49$0+*kJB(gfpDy7bQD`^n=gu>X_lqZ`dvf z=dD%Oe}pM=_0{`^d2cMe_P+n>S!3HzRhAr%UxCSpt*H0jT>aT_sksIE)J;>YNglf- zFL{3$HA86{<29TKk-NyNKAUqBg(MDolDo9KctHBkiajX@i@e&-(zJg`ett>M`EBoT zr6AQ8A=wiHnC5;1WR#YO7A%Zrn()~1H}~R_3(F~xfIt836C)~HF%<-=ZN%AQdo&0|usPZXvj_GioT> zynU7X_va^Y#{2lf*Q-0{^=yr6gr+B6X|3VAU*dHS+q!MEof6j0rdW}c1TWf{`oe2L z{z_=v0*H?Ka;fUOmI`@Dur(fg8apRQGl2(P*YF*}mh~GaMW@3za7XVNk5?assEyei zxMY4Xbc@j|3qCXR$nP|*?AgsALk`_;uu^>+3UG3<(y~_=ay^E~x06pvvBM5uhM9Lf z%B)+)6>%qQVOu*`%plG-(QY^3D@S}{>W`=Kd$PDSC_yj#w>e7)IVf`2ZiDf-hw0nAR?ey3rdth1z~URyur~Js+)n|n`Q!}O z^wdO)cf*WorYW^d1vsDvDvK@i@yFIx#oT}6Y>gtbtc;G4&fv2Muf=(`oO=_ z`EEo*f4EMY1U)ZJCmUH63{%H(v7}dN-%0c3%P-Hx($F2#Vnt#ddk(PoC$2{8tgMRDZK&5ZJ3Vl0=!--B*9hgI@}<|_Xl}ppm)KT*Q;3Z z<8diE#&biEckh&Pr@J@v1EDPfG}Vn>8c>r*T%QQ6oZ6-)HQx=;e#O>hyVyvJ7NxV- zSZ(7t`Yt_d-R1EmA|6~9K*pcFq`cE6>U8HQ4oWvm&td1_{`}-H9F8^Q#U)k$X4Tg~Kc`j!4Qi~R*3Y4D2j0FDj;sc(!{6mY2c+#Zt%Kc8{;ZEG6 zGtlIPBn6bHp#-*G)6Q9^RN&yAUCzAg+CQ8f+nEl?CW>dbKJK6}iD3JX-h^?&ztDIw zl@hsj3s-5Do+Uc4t{$03_Jdy@PEewFh#uE<0N|VV?P>sp51C*K?P8m{%WTloat$t3(5k5Hru{H~hUv__;wnQO8mJ?289gkzn;qzhukBH7Q zpKeWHF<^rhI58B5?fxjj!f1=9BOQH0>KfZ)%dfXb23{kRmELWaSDlVa8!`ynLx;poad^mllPI@qI`mQvQV&*_s_e@k|IcDR-gjEz4ak8e81$kZlEJr7Q zn45N{;?H7LM(52$S zOKn3`r0jfKSC;873D@~pj(+1YvJ)9N|CY-;Vt49a^^rpBuh3s8WnOxATmK$SZWNC$xR4Ag}@Be@_t?P2~nFX}%Zx6eNw zvB9pwh5NWJW@zt%*V!>hJE4-WT4_%CO!!9y%%6fG~?lEnF)a_kizX*jb(DD)p{#yywyRvjCD z2rcis-Y%OYDAcySe=Z<%X&(Z4332MefuGb&G8Zseoyh%qI(3zH-5BWnv2i)OPIvro zq6{YaO04MN?KAk_Q+#G{5+Z|Jq2y*8XoU|SmZ_)*U$u38nBaerVQy_k6wMV@_~C(( zPRW&CPC3;UJaj8_jnU%O7?BFs>0;~wE4Oupeb{DJnDfL}JIaN;LUQ>e~`3p!t535S41r!dJwm5k#!W=!)NN>C{#5!Mn`ZT(`?8^knZ zT>3CG-}GS9KinO}*+3v>{Y6u9+1Hn%7_pgmbN=`?>vc2(u}yiT1okd799dwP*|Srj z(v>XLD(Tj`WDXZD5p?}wJ zNd3G6KSLuVkH*t}3XGBKkV4H$gg)x(PDgR$wZ)K3fj-4eog8BGJ~) zis%fb?Kc6x9Ox#jEC*hfR6}8>&gg0{6Sy?;Q4ZZ)~A&c$VvG&x4mC{yRU zQ5s`6$j`EVBFGbx#$hgp#lL6DQ^RDUeEh3XA*DGa!X1NmATx4j_pu2NSBg59fS2?I zRDS+FoVx)Nm6-5_dW`cQxLEvtA8JyTLuMqJb6tJg6FyNzBEqx%z9j^o?hj&F3O-(L zLf9UI_4`h_u1{b;ogyxZre})t z_yG;Gq4wd;xs8nq!nuU<$ho{vi9hOS>jdkpUKNI#B$nAy@B4|D$c5xjyyr^xM$~KH zyTdd4*dO7mEXnFC4;{{Z-U(De7!U)h5|2Q2bTGTC<;;!1e_6J77jfEU+Ge>w)S971 z8*_|*-~Ltd(8I3!dpxLd+Vw%%^QU#9%Wv{2a#}ZEe3^~pWhxU6#o0MZmtQ%*c4LT3 ziQg=t-4~!!&4fKr-EaQtxQMHB7nNTb-Ap=>18+^d0{1M`GcC66UXRpaQJ8AjrPcuF zA3D?0v8$hOpID|I-Hm0-$b#d@NzxIUD{PNUjVbpDA zzo;Yjlhp}a(zuqzrg{v6Tli1E8dJ)e)E(-=v!1*EGQAeGue+jZ~Y(^2P znL+aG$;Dkw!Ml_3KI4x)iP;9B6L=LS{A4aoD`scTY2C{oV)_j|E|Kko4xN8zRR?L6gO!Lb>qCx^s>P5Mc012_b<18!)5H2wiO=%->k)fW ziNNROMY`cv?WG29|G{%q_?-*MRp8aWGJ?&^hq|N|2?{zTRfaNP};dp_k*8zu{D0&b9$TB z?M)`hG9^gpJeo4aDx9Pc$TFQI3lT29KB(IS*E}xRoI8{L)P!5G9*B|ICNb2pK~7Mq zAW>yP>Pb*(!JT^F(;$&YR?VSr(x6qK6&EQP_g1*zPeg`IA8;MS=@4Nip%Cx25aZlg z8$*wSpy9i=4#p{Y2rayLq1F}y<+q?}@wN%t?Jmo3p+?>edHF_B{&solNkIy$a6KuG6qsP{Hr(|tW&9XP-z+-q%9}3{y>rY_t`_U>BkKJcaD#@qSaNw# zSK)ym8%DgoZZCR^_U~}t^$v!@V$d?*cScuaHt_xRtN?5Ow67l>Yk58Ouq#(iVLjD2 zwG!8*M{JX~=VxHhkF87lL*E$wkRE)X9h3t%PA$Ub(PLmFOnG`(oOEJDo6frrNskR) zd)~Qk&qOhNvly3SxZvqVJ7kA6c5oF9p`8TJ5IBg6qv?rrmOtFa3Cc35s^cJi;>WU{ zeqpIkS6RWUYgF!PU)*Ka((~6Zh6;M(kInQdmy1!&OIWm+-Rtg5*GsMHFM_}U3V%n0 z4Hdf_jy&EU`PQ>(8k9F?VE+~AiNkYnZA#R-G~jb%72-JKpOrt>yF4w?QJcW{-utXP zy%4#O31sJt>4GUKQpEz?T-tAG-Usv0qc)y?t47b}jyV$!`H7&?m*W=OGzG5R=Gkh7 z(Cg)_v%A$CB$9em@taN7qmsprBAjQl=kS~_AY16{|{4bQaez`HBQ(|b=s#uO{TSIsTnJr8RU{l5M{U7IJ8Uu`SU9VbgMMV`{iM{uW11mgB+ z7`0a-t?_58-QE1&<4}nD6l{?6OfscHN-|FsGmHmG_ePvWs-TO9O(xMuj7%|#M=Sb5X2u--PZ*My;{Fq!hHn=>wAZ#T!aedoLeAV>77wV9cz&=7k)V00+ z^kxKo@f>#8#hqkfr=5EYwdmdUwdWN!={uc;)%RadTB~jV2;a3FIuwEL@3SAoySF!6 z-5C+Fvq$##9fvK`kei#MnugkkfR$d@<7nQvJ48QE#{9ztE_f3+&p1AK;<4RX#8ka6 zjaGe3P@Ig5R6ul<^B9N+6wY;|!rlIqs7LE%mVf)9w!FJt^TV^KyRP(8Bh_6L!^-w! z?Ckr(jZ6D8hbxhGtUT#KRG`|SqR({yKxrT9Vp*oM54e>QF7c43GL$nbm4827yfTe# zyWX^a!Yh(cm|!Z1cFO#r5t{oAnz3{ax1ZWTZ8MVk)Xr`UU(4VXoN)WWk(uiLo*I%| zr|FKVoKpjz)&4BC%_7^u9C7})41Xa__?9+xF(bu8h7~YM?v?b|KS@Bt;b4Mnfa#Wl< z*FEF2LYNyE>5sg<+7U<|aCFP(8Cs0r_ql8Ry^BXwgp;iy3q{+(LTtzm>+WHj1gJL& zv!+{%s`L@flNOLj6Xo|dJjEKKG+7V_8>7E&0`J(-fJE&n?w~3+_Kej5gb&NjfYy8G zXxYX8A)fN5kP>qB_I|}g^j?W>I_m?C_7V}V&3_z8mhEgVDsESVM{~JJ;4aCg>Y1hM zh7G+o0VTCNrb5*c4RM;eF1WpdmY+G3`+xkKp=b2p2pVzTb%oV*xg@>uGguRn7`|Jd zY=rcKD+*fsA4kwf6C9ZbL-6D zt4YY9+ z)^1Z&me+lrGB3>3$ANn2i0(#6MAI-$aV{26g+Ce80cgbF9M(4?rHYSv<6IRH56YoZ zE&pnhl%iA}{n3Jf`&G`(IxXy92hoHgfe!^n<0|&e82=FJl0jOr*ZoMU|7J9(U@t8; zfAuQ5`SKPtT`n_U%0FV*J)t?#RCaRID&uHuKckXTCvup3^PK;u7DiQMzIV5d6K5!m z=8)(}8mpL3b_jWW|Hha8ptYvQx+&XFhLf9GCoO$i5uFaW&?9Ef6c3A?=S#I%^spHI zgmnT{$_euYe~XkSLurL#=uPUg#^a@gQPCp$^H*$hI&M+l>S5u_OnJtn-Wzp#Hxu!b z-i|G@f6YdyogkScLb>j5lY`C{vu*4fdJvxRbY7=@ZZb56!!a8^vi35c?D{{B)J?F1 zeKlGp|H_s0>|mTzJ*{5qf-({`8F-DYr|lTBpuNaH&^XCRE9rr=AG|3c%~%Fxt?ZQa1D!9<-$J)0Intaxh*Tf2`d zjnd6Ls^r8-|Hf06;JOU+Apmp3r*;cn^**ad1^8t{omXHb&(|I5UQ%&d>+=hiQ(l`X ze$tnE=hGL0fgTB5(Z?8mRNvX1Vp}<=d!E5qap(;DF$~xfPTc3X<@}8TyLUzyZLaFr z8C9ldwyF;sdl;Q|tE(o~hPxh}#>>qGdiS0#1R2BLZz%YWbRFZgRvs7?qX+pMs}kNk z3wHiW{A)(d=l9w-!SxO#Y1{d`Xt`%ATZ&o#tS$i*{vxb6Dcf#ZF7(Z1X0aTp z#pTN`QS^C4$LGwk>n1QqKHe_|!IiZ@<49c8E3ddY8KESZZO{N$d}i&@)M21IJ2*V0 zRzxlrb%!aNjW`V5gab9TYejffjJSBT^mWNU3@@MxbzF0`zy4$O>B-bg0-KmrE_gYv zRz)i1lq|J%4ek)KaL$u7`{Z=z)IN`#K2}*pzv}OU#2*6Ya507{W~Q@YML263y#`a( zC_tk%d6viSE4}Jbg-Ac7PK16uWCY-O_Y^hMli`2WE!=i~LUD=z=zGBIS>ihFqVDhQ zsusihf2>nCq0P$Bk1+KIraQRCiXEpn30-@Ui~c_psJzR{guKsU^%l^>5Z$RyhDOes zUthk=i>IVj4N^N&xIgmnFR#c<(68KQU`7Cy>gptfVg4p`F`(*o1C%RsVNSH^udO2u zhgh;k`<8U_E%NF&k8Mvx=i~oz4d=sCmgCa+;o%t0_(MYVlQn4I7#5PaDtDHi2zsbh zJ4uD}9oUMPZ^cqdt=_{78V~Gu4;9WO&gS@{D?>XGd0p@^i+xXmp%MqsKBQ@nKa@mS z!z~Bv`+v9=^{FnHtj~*Ve6H>1Q(*4PxuJ`TM&$IPoX=1zrwnI|9_Ogzp1Ii_7cXSw zp=g(F2qR~w$u~dDIGi-&_-OmlRn017Lr3=&{z5Kt?nTxl-#w!q@ri^?Gxsm zntLhtw8{5;WFM2jlpt&_4#ShJ8q=OTFJT$>n$tQ?H`$8LBnY*HDy) zMtT~f-8Su4S-Ah1$LuBgBKdwEFO%1OOPl+SOaq@&%I~)$=NZWAzt5rE;|3XqmoohAo+CZ~Crj^aZnhWp$~M~y{!etY7V7m3zVA1HPtf2r$XY9&KQ{YT z&a0^LA)vo1eqSL*n8xcIiU0=yQ{P|$-L5P2m3h(6KCbP2`SD_aeO$YytmQ&EIdxp+ z5Q@XW(c?xIfxfYh5SK+TGJSyLx63Fj`(E;jY7i7wL+O|XNJ7l|z2SLva*7=YB!fY7 zz#c?&36UjHQ6cPote8=B{&+yiBN7{@f@NvUyq$(bnuS=1mhEQc`kothi&^JzN6;P< z^AoM4`9|=G5S8`7+&U>m0`vGko>BItB-ZQOpWSc@qIREoWxg)fV=)P4ayIo=KlRS*ubU@*Zi@IQPk&&{CuqT*6ndV zPSI!p@WcRVBQ*6yXu#0K@d$uB?_)6QP|AEV8>2Uyb7|!x;FF#f*th9LF}_3mwL>gw zGJR0Wd)IQE8fCX)tRO|h>A(0~Tv<1K2oM!#`2KDd5$EYd`!Jhq#iDpJv>->P9dFU}q}Y-|PN5#ZH&d1%aw(4C7C*!dpxoY#1o3 z6iTy8K1kZWhU(g4+hVB-KsBvBsz~3_kZQU)3g(vxICi^V9~E`It$N$pZedp6d1RQZ zvHEDZ;CeB=T}R1}a%H-J{@h#felVZ=^ZQ{oR^58)iz_f`>zLy8=q92 zcLZqIw78iyh;+R@rTAtNEXCH~BQtJUUd9<_cJ=S~qmFH$p6UD;pZK(%j7$NtK6f#P zkLHb%F?5;&~-{Y@V%17 zKa7N$6EIbU$5lP{+fNr@Ho+4U?Ag4`uZbpL4f(KS_cw;Z$-z$p3l&r zK6w*|Xw_Djn>wg{}2?hPcR=5MH8URupSJBxC2(Hrz^3bAML7EeDmXD9S`4a!Ay)QHaz;M@%`Th zz2>{X1QoZ!pzc3JmF3R>y`%F)+)E_EJw!NREr}(5si!;{vD{)!nvw$=-YRGQABaj!WNijufI#1>=wyE;xcl^PBP#6&&z(PTy_XX!o!+tU6;zcmX6<*O)hjy&$*RPc;0!i7OqdN%N`t!16lrWDaXgqOlrTm zRsNx+S#UyIwa-Qb!|`QW8*6&X@guH|ISl4}T-tj~cD^-3nI71@ED90@2e7A)>6=tg zWhKEc2Pfz#0cvIVMP<3j`O>cJq;5u%LD3iIkL7s1|LkDmajCLqy!XA~MRj=4zGuys z*!7;5tPQ82*5r4bv2{Ky8)oy#yJ1WYu(s}hGNQ{lWlj)~#>#{3v+yg7E{K|M{BaE^ zt22?KEv_F81u8r?h|Ppvu^m{%%Sq(VM!P$U;Y+b-DJtB*Cp_@Y)QC zmuNtp30ZAo9uPVf)cJ>&Hz~b<&8TjAGspQ|OKp7W6Wut-?U`@ByaL~6%D7!LM7e|p zNutoBIR6!Z`%(|RG9j=EmfYF-Rj(Z98Ud5FWmUhc*&O3FfQ$*TWT{>mv}?pDm5{k$ zRz0o_3S!Eg;5oi-p!P;J4p_ony#Nsl7t;-L|G@83Qf;35><*JrG5wnD6KF7QiD3NH5L4t+Y+2&{c5Az`E8drtAZ`wtIF zRT*557cik{+mL25GO_3M%MlE&t9MaEMK8@v+-4TTkoiZk_b{{g?LO7C%-STa?$8sX zI=s#rtLK)=OC4#;DUHQyCos~(pY+(KntfMO?q+nC0dwGu*ZPAPO44S)+sU2C6Y3ju zTb)(q@WxaT;`71>>juhrr_$|G4%^1ok)mFZH9Ww-T04G`D-o%8!kAvIMxKl!64pLx z^p(s%sS?u7(>VRu*=TyvkT)GsE36F9biM7~_t`L*zSU(qm8gGwJkh#gcqiHgfK$>k!O53J^i1ciDoadTd-%S=j8HF z@ve4UJ3+Itl~c=iwN=^#^7AKyQ-G!_a{&#~`qPN>z5s1W5)wlX=lMe$I{Os+>z=Tn zbn7TkAYoI z46P>}QO152w^8hZr7HNkL}dN5IJ<&dp^NrgRU{UMO(aBQHQlU2Zw2tGD6paIp0UtH zd2P3!BO8}rfyqgJo|%p;9tFLbb-X$3its-=7fu&`85}|25D`H&W~K7bCj85# z`LnPu$Y4`1{<@j8&OMm3xI`Ey+p_pUji_#(4&j|ksEEzTQ{g)0B`#}yHUQwX`Z47~ zhO;;>^rY-%vhDIEt01}-j$c&j=$T?&F&mx3Fjy0XY|yqp_m&ezS;Z^9db|NdK#XaO z5pk_>8P6nY3I-(h7jM8HcUCy*B_D`lMfg{`%0f`v?o*Oe%n)Eg?Q#{rklZh#vz!i7g16ulkhEbcixY=qOgJw?-2ke z!Dhf|+DO~n+SEY&v^ee2{>_C)g>f>9AvC*I1ylO_+o0$m{#?h4Mnj@oh9~esD#r=B zjO4A~{C5{?kts&pHp|M*ksK?(7j$mG{;GXVaai(&xKbw^5B_d>q(&ZEYhbmm&(_bD z#YsKF-aT;;MIySg-T-Uo~sz8%HOM zVShB>KNt^eKaRv;W?L0Q#QYJbad8o{hV&oE$TB6-?W-b59$60hg0f#|KES|4v?*} zP1POetkaq-DR7dhMiD9Kh+z2^+QXKHb<{0+l_g?bPUigSIdisP4AG{qi1Nsuy((R1?);%8~j}t6UEYc$!66gL?$mOZy7g(wK3U6E6;LT{{C@Zo6 z3bE!>IqVM}#}W;pDNBjiS4i0?1uDV}rKMFi4hH>3j`RTYiG!8U!-ZKMEh$W|LB zT73eF<x-65t*~YKIwC88G)@k*)?Rh5!T3cJE5~x#B|?8( zIieCze-(;+)D9en@CnZ|)Bs~y^?Bn!$Pj6l`Ul}+7hIRiX+0^mT8u)mZ1~_%Qd9L< zu6DdS79EC*Au-W2pT$Ige2;ep)~4lE=P`!=Bwt)XHgga(&Cu}Ro-v2yx^CJDw@7j@ z2pKTr$Z>`z#>DROkTG~Yh|_?mKF1HL>;Q*4*v?h;)2cFptK2su$KN^ZmW;5Ee#V_* z<+T}Ivtq;)H<1`X2EkS6TtM=m54Iz&wi4y9N^%z0mUSYGVbWZrk<#Krp)TosJ>7By z4&p)l%IsnhS^Plbl%MA>aP1$y3Ci(@rI&J(q@->|wsR+~2`W3y$sYbN)9eG3w$`Hx zW4mMISqkdthPgliU?=9+&(!}KVh$6BU3jOgzQP7is5?blt6wGIvdqghJX&hfAX141Bgxyqa*l-V{o@4rT8+DNyno(6inBmO(;Ij-Y zZRHDx`D`3V;~$vf^wY`QLes$F!Di>7s_Gf(b1XQH+tek@`eXeF0p=#FjXN@O@g^`D zz1z01lE_=%ba_Bt#9H_EBw4oSVc^5m;4k%IjISW7aJnIv%%j7N*`0@R({r20sfz~d zytQUdt#V)JO$&ccCL`JVePl3beu=3w-P#m#0>4Q&K$pEt9Dv6q6k(dl-JTBU>RsQL zMLN=K(y(#g)@hZ=bt~nJ;vW!(4RO@2mHeWYgj_0_m1X1DLHPnRPkHvHU_3IN?(T&7onJS0y55 zXqTUpDz`SOHn5;xi^eaLrTJtJ#+z_5p+X63KZ93d?FD1l#l$aVzze5|)36cu4F5I5 zRK)b;vUY|I;P_6y+6f1{b;Sf;+L`GQor~Z0VE+;&%Z2W}p8Em8jp3=?f+)1mRtuQq zjaDq-kG(}UZl0MdV~?_wj5F3W%_9$u8Ow27H-s=+Zx1YPaSIxZ8x@tpw`zdU7DZU~ zm>o15nepw$CYPi@y+5nD`Kk+uyKUFkPk}$73MSNf46tv$VM`klF8J_9g9vL;2b;!X zdS;WKhOIlEs?ajPFeAVC z{v#X*nf+~Dhe8@}FtZ^dVBW}T!E7616r{BQzLWC~@jF+mm*6JhNkYZEp_l88UBARS zZAmm(5`^CJ-_nxeWMqFN=#S1*n}Hd^nC+$F^5X&(LPuh|6wMD3DeI*`+_S9L?mTuW zLQ_A$rg=^EScm#6D8awBRcVMRYq@qX=5aTREMfqTBz_EXN_plU&_Uh945E zPop>0!7N){BT_heB()yWna1_ye6 z+7elov4HFnxx5z@NtUhJ)&W&2HTUxhUAMsF7IfHlN`jGYx!*0skM1D@WGnX>YLES3 zi2f|_#l8s@>;z_-+GwN8P08N*Ed! zeKH#{*XSon&gpNmtQ4g&W_0r~4jNpynM`BHjY-;k7dTA-Th3~y;>@=U8+5BM&S0yc z-Zn2bGClc`OHwGNNU*gl;M~UFL)PloULJw3ED*~dE+oRqWu&mqZ9S8mVol42>kdk9 zO7wjUsZrRDXXPD*Wju0R2Hg}opi^}3w@yphge%i2FVVkg{rJUk%Ke!4ctF!{j#I7d z$(w)Zw_=i!cDb`dZPe04F42Xj3n7(XQF6uh8Nl$^{ zw{~j64Y>u%&#z-2h9imD*w9&OhHX5Akb~kGx{8x}QSCv(N~8#gvS z%SBtI`<}ExcVyy$CcQmC@^<3a4BD=tt%XlI=;KK^p%(+a>-G(1R^WS%q8jw&T`(bV zchYd*q*{Lp`y&9oZa=+g$e`%_catL#ieX|FV`^icV-j!_i9Um&-p4~1*B90)g7@#G z!ZxqUAI4Ej5~wLM6|oKx1M3cw*GpZ4kA@x4f|EYiZ!?;@Kb5Ob;K7LtjOw?PEk5w- zYd(#*)lC4g4@40B40&KPGRq~GZuB_5ClD|tO{7=_Kyuir!@V}cY4qA2mYW&>8+$tw z=JyHd=|tteq5Dc2UZ?(6wgr9g%wM`scz-v3*C;V21yY?bNl!F04%1%}N+&2}buvW8 z&9VEb5yn!6D=1H)T))e^+EuQ+7C+f|l*{h;qDStlTHPG8ZY4X2qHQsMR+Vqs?G1IWkH_i^6I+sbj^`um;(K@Hm^pFn_IQ}6 zvyg0>x?`C$(n!_3b#xzp3QNwNCO=3y99 zVJzpi7ttm}yW!b|X>&$QBSJoTKUVz)2eodg+ZTZraW|p`vvi5Ys@f5EIvRFSK6Hh?Y9LEz6-##eD}W~LQ8Im=oCF74!3+&xJFgl{ zBuvq^gB_y;T!48PR{J8Gwpl*#>eHBbt+zIT}OCw`2^C-de;F4z&n&q1Z=WpI!ZoWmXG6 z=U#+P>L}~eGS~Tyv+63w5X2el|5R8z5hc#BI<))cpS5-xJ~8#bRrOj(@Y2s17+f#& zI&86T?4V2CKdDGf)j!*6NdpI*7I!eWD!QKP6c(c1e=YxT&xv7_k&RQ8IoT!aE({Mm zUf(opvXnx{l|%a3LZ;1iKk-Li;8@d>nvrEyawC0yH}G_pcd;fLZNFecu5 zxNByciRB1G)D=HH@K^oL)UIUy^(4FK{|_kM=IE072diVI#Fn2x85z{N^-NTT=Q@^t zZRTsCFJ@U%U#b!{F!RZi6FZ_{!56tUrsv|97WiZdnci}P9Y@|U0beAW;nRVfF0e6K zX5LJUa30;l*vf{+z#`c%#^Fzb6+CC+y*K%T2q45Cx^}Sx55d!wz|dg>SK{;~F_lyr zG-E;=xq>SNBMl0Ie)<=)TE{J3_tji6KIBtMHY=^_{iMlQlOOxs?GFyz9t5(wWc$;m z;S>-Okb9y}gHpr3r8YzQJ|g%QdEBkarJD7s+j7Lwhe|Sl(e{G_XZMkLtnX841*vtO zd|ndGT1@$mJwRQv=Z?+CZHKtNc7;GSFkW=IB7mQ1uF*@fM5N>R=eY(NTGTsRgO5>+ zJf?3MA7>wUrdOPv!{r`O-siQLR-hj3u-_)WnfYSephft^*CO!xQvPZLeU67dS(ah{ z^54Tn3F9#{#Ra@`q9MNfqOAqY!hFDkSE_6MdD48F)Rd^18pmhSmZ->6ypFhPwS9Mh8Hx1o?RA~NfaT%%FfXYE5Ndo_kvIE0n z|5^~=f#Le%vZz&35&nVb3~Er5I{04QHtNH)vN;Qq{?Yo9MTW$peyGxK?#&c^n++%lJx!hDi?!`4Fv&T)0KOHpLWobuC` zEIPT60l@Vaow6ih;axP$n&)=?knw(K69Z>AKvH}$c56YGL=Iiih3*IMo54eO%WoL~ z{Hqn@YrveS^WcUCODitl_Jaq~3Q^?YtV3ddW6rOK9>TQ}sdq7z(~5&}@g?6svm1erTg}9Fq?q zhMQKqhHpCLu6_vK}beXvGr`; zing318N-P(hZ(1S@tMNmy|S|U^XM~8r$y-Mz^va%#9hBbube-9W@V@}4S1MNI=7O? zr+)-&v6|?%K^l_h9K=-I$J!MYLOutd2fE5h^+WbGLO9-!hCi7CuKrSns%o_YeZrfU zDKq5(BcW6@c_26dFxbju2)1tsVKxVlgza|(SBlS-m|nZXUFDh|G%uh9-(!ZBv?r!1 z^n*SRLv7$+mB7AtMZmlVz2OuWL~FOpl`eNb8N;r4^OVCs&?ZOWQ$Zo?h=)2M`6FpE z_)l=g*kXczGx>*^M7=SwKU~Ogzgj1Yf52KVz%%5bzUw+e=GU6OXQ5a8QJQa-r>0e_ zM4NX9?Y1lYec%Ho7=^t&iaIiM4Q>q@5W&?MQ>+qf7fKqY5yv|!&36ApfER|G=ht~T zIo1KqYd5e1-OiSoTLO=gak7yk$E+Aj3xA^cUYin_R%ovSQoX8vl7*-c)R5OWOt?+K zlzzU4KzqvgPEuG3C{4v3X_7FC^$?_$08gGK)71*8;lvkA&T;uPG zSXfSI>7qzvl~)XIMnlCbu$FMrKd7F!vJy+DP=5tx6V3^4U}y$VSrwO=JnZkNWzxZ| z-i3tDFEc{@LAQ{irl4cPMbLQZx`+;A>XgVNSb?H#4Jn8IIhK4rmPBno8b zV)xQ37X<3RRnnvGX6NCt&GOI|Ni9DPqYrZUNlSwJN0dHyADR<*_AYbU3qh# zCaJg#@LYhI(p!--w14+-#Nzv06%imT|mvF$0>N*#bC z&cc_!S}7n2yo~7C**PJ!$a%{psTk~er@G74Db3ggnAg_euJG!n`HfUYXALgg(AJf$ zi3gAC2p+KwJKPYPm0_eLy?A9;*Pp|`pTmjlrvk7PdHbv%=Q<#&u z?~71v^pwJ|=!X=3mU}?AM$JM5+5j4;E zkFzY?AH5CDS*19l;!JN^)Y+c-ufA6#XknAbCA7&cKv+cf#^l8{}*yPxYTjIOrosc15MBsuwc^uX(t z=?wj_tW#tbl!$qsRY6pg=E$~L)tS$A;Ln{EEDVmwatuD9ZGLAX`(qGf*4POip0k9K z5LNzi07{I|vPjO0^?mgD3lXP%=Hx>CST#k{TG!w=5y(t)L2YvR4~BHU*P%c_UG~v= zHGHLbQYgZ=!`!Sak^B4bR65kxIbXMxPfF4QLl+WJ90jXz1^ zZ`@^L9I$QV5;NtS0~mHs9{{MPI#c8Cdfx>?2bM}&IqXYP(vu-w)XnUjABQtff;q~k zZ1&hMxn(h0S>&r50KSJc^r4SToQ^hQjqpN3-#%j@pqgnMXzOyNNYKE-vk(Bm%@;TR z8Bc1ghG7|Y3zx$X<2SZgg+A(pE;FhDef*Ls6!>tF$~w^F8k=2z4mDr0D##h0y!&2r z1blu@M6DcppGw^V$`zXRq`AtjbNq5hy%l4|fp|I$@*sOJAS?>zGKTp{a%d6mzA6(&wOX?AR8S*E1pu!V*<=)CuVc@7?Af^Y~HWXG~ z=~cxiv#Zx(`MgiJljWsKHT7^Lq+@|_ z1tcuv(lWS!_2Sz^`^xso*VfZ1dJ|cU_cwgY9XhEXPz5X=fDJ{XZzCUseA?)EnRwr) z))hv@deMBHGLcjzSg0+&paWKKhI7-wNd!gP#XLJB+AL$JC*W&cg6O-hh2_T2oLm$% z%5c|T4-RLc5CEis*&~#}`DLp%WeSl%$%xxm<)^d~rMSNwQhb2PaH_HvbWV^?dIAm% zAzVUS=a;am8*BKvXF7K&iT)5=0=h9AIH<1Hh>6NB{KHdIt5#qftv1FJ8%Hf;55ygA ztumh9Z+LM!!qWCcOhnLgnOBJfoWjIl%YgA=WdWq-rZ~Ai4x{&*Tt)KkO4`e$Ja{~m zP&(j|vSF_S=`IwW*+8t77LXJ6xeWn*2YR_H^Wx&_HZV-%EZ;wEg70e%_-s+Um@HJ=9kq6QS}L4g8SiV$2FNZ4$DH)0^226wfsKF?1p}n7q0E&4%sdZG>+jf{8A@q zl-+MdkodBo__6^R2Dnt`j@q-uGd3x5;C!|UD3WS2 z4)@2h&^5T&BEQ8=Al-Yj*+mj~KKoj@p?S3l4@Z$GhTrMhLzIUin}eM80+|W;X!PzB zS(J4A^xYqa2uP7H&T|iyrzL$_cO(hbUi^~-BA&;6>g{*(T+##rjtSC@4kI~|bTXgT zlFZ|~n~0{SJ`L6@dNc4G|3z672eFgh1N0QI$=n(VE)$W9p5uFeesvGP`)ANkhqP^L zOTF{H-Rt1tKwW{t2k+oq17_!DI(g!7!v55-%Xp-0BRTNS>u28Pa*8#GfJZkj>_xWi zP1F2oAICA}Vpwe|EX!^iGtefU>{fk_eN-FnCid+s+G!a))x&XO9j+t(_FdqU>4Cj> zqhFH6bT-cENPXicY4g$ZyKVa_POE9amyR<)U5YCH0TPgcd%omy1q%$z;*}uxhq_;2 z`v0O*!vHw{iO4u-gzYb}yvo~{gJWGE$e1!XdHkZiy5p+peNH23A6vqj?AGqUZC$J_ zeer@5dsDAW=x%pSM#;@?3}8gR zH{fECXniq^;T2ZsYvYAxK8)5*)QiN9&}J{s^9|MdM%S~Tki9fRIxLfW_nG$uT}64g z!3==){hCl@Z||597MR+G{_~JQ0wVc{`9s;S1cPSPcxhrjBG$@Ek@LgmXkZX1FWP3U z+4bCOKdV!&bF9u!2HJ#mz!#NLh5{Vn%fE0KTr4{1Luy!-j;zF{O$knYgC#-em~ z#-gN0IU*IcKD&z1ZhiQGfqTXod_ZM+dnd##k)QKoZfTqsBm(bZsWKamd`2d@bnWdh zhqfO(q`+)o?HnSWs6P>8=R1h|cFq{mEYgguJlh_$G}ujYL{eJ3Rn=pr0Yxe;49k~a zQIGcA&!5N5qm#h(1R%L)JEC(q5Ns4(JC5PvkB!&+tTVA!)Vx@`STFv-->buyA*TM` zUG>~IX{DeJ6d9g^W^i}eKM;q2&GDaxur=DW{nl2&$2L$az6et?#BIN0{!N=Jo5OCB z<^IOkpLLYd8?s;K?V!uJHeWAzae-tAOen}4sL#*XWn=S()0YIzCJysd zt5Kaw^ojPNfU9fQI!a^dc+%ili;f@h#W;sSQ=O5SGgZ0*wB2jP3_uw1DZdij1=niI zRFq$vaGiohvNqs1qk69;>2&$yVVv^{Dw8$xQI4lz@n|G}7LbEZev`Bx#@brUzQ;D< zpM4CN!#w)S$(s?}rEEsKv#ob&zaA1df=23BT|p+XDPDR!mgro%RCk`1u#2HgUw@VnrmxtoD||V6oBKd z?CHdpWEo)Uz--)*Cpf^lHtXEI#0TPDySmr=1WLB~H&^wIH2rrHsI6Ya>JQFV4joL^ z3IB78yo>gejgtd%iNvz!-Ru)=U=P>+YzHPTqaskrUpvjIszNN8L(f0Dl4Q zBJgk&{4C4tEkZ5ft4j(EGTC@o8Bdi2vDn@iI30jooev;>XgHfI#Km_(zXE|su0F%k zpWuJ5FD9wD%fk?7(}TgzLCgv+nJ_l6A1mvT9aBQ8Xu&?&rNZbhK&ukcx4P<;Y1~0a zGvmr};uR##lEpWAph29?{9jAqyEC+Nl=uRK1Fw0MJsq$?-oQEs@PD#f5MNWqDlZ+T zHzktmVxHg2Y5!>Zw&;1~gzWWxz404M{whWv2aTfYd`v+1_k`X5q4b#^w%u4`o8OB8r^fHYg*IdVF{Sum5rbwE%c9 zKkIgJY%GiiwhDgW&#hxWU>))W(fV}jr_w}WjvZpV91s}fx?ip!20$1Pr9dPSbA^d- z=U}K{FX8^0F|93DkM+KO8=VZY92gp)xUmsPRp7?gUtX=B#e;(`EO&fw0_Mf@PLzJ+ zeF=^j+$^Q4ZgwLl@G=2hI$^9)Rx!j>fPt`3P7z;j(v9Np@x@SIt%BU%w2=iO5a9($ zPXxWUY8j87F#Vc2Wl*w6b4~?G>D-AJM+`QvEo7Wcp$qnbghGvxwO#AmU5qbCl5e7|kKp;&hufo(u5)Il3I_#>PTaBCK9=og3%g^KP(F zVr|SUM#ACe$9dAW#uoV{1+a^5Ds-$pnK>sJQu}<0=o!IxhwMPU5m;+h*XOZ?8~iMr z5HxEJxpCKMVBwzm7pYi|^N~zp{ddp9kvRTbOjXGx%~ILl_RQ+5ALBJR!^etp++m@y z88rT?qZK`a!b&gmBFK5TP|^gLiV3Q22)oWnmH4jV&?gh9V3((@9HAhxK^h}$>v&IN z1Jn#2Ejyh@l1;{=sWF%b5;6ONJ8`HZ#C^uV@7>52Ou3BCduolB8OUzekc}}G98~u1 z(?v1*qf1_|^Z(a(5}g(qe6h)Ny-**x6yX7Ez#e-H1ah!@)T9%NX7HR>cSS9gO8bw;mOv3yol9n)-=tSo*Bch- zpMErdOuV=7$DJ8d6?lpqpnI;M-4`s-knmi*d*4VDv;mM~@iV~*$|)T>Py)-RAY8WY zn`A7!_sn3xH8+f)K>wQpPSWF^7#()by_{N{8 zlS(Z3+J97h^!^ESx95i;4bwO$SLC*pPHF})=zp1#-o}rePvx~2`^=wU9sVozH#j7` zBDT+zKqE2wP0y>y{|>~u>a{`PmWHna+88nIF}9no`U{az{E746jb53nM-dPQ^e&;X zfYIZX4$>l)=K@j8#^&3LI1c>n(ITWE?{S%sMF#z0sTlvl$Q~e8f#BTgPSqN1I+(-4?TTDX)Q;=}@lL4;o$%g9-{lq^ygd^Mw8F#Qm zjd8GZqp-Wj9K!0tXu-LdXZdUGa)#!To<2hR!C@(8Q!o?b$F2JQ%KF9I6JGJ@b6mNBAdhD$i zmQS6nq&=3&x9@7m=E@Op2ahZeXRnUfr(>9hgtC(c8@LUPzK)m4bDCvdv?06sY2T^P z0CSQ3EeWR=T{c}ZxDBw9s2f7Gpnn{t&py%9h_1M zn>%O~kjC>Stu`!3j1fI~V^mi4<4r@SI#{YPKD+}eeViSJSkzii#?_WrhQmIYgLs8Y zog`@la+SRE12JLlY{tPdV?AmF+BOht(5y^J61-oFVJwEHtg@s8*xVmJMMH+AF~iIX z$4YvX&nI3D3dAP8|6dRWNcHeW_b6odsN^RQr!#Jw0d)2-|9H&k7xvfBhRF{I_30q0 z8ehYKwG%L1YT0Cp_t(&SMiSImA3oVXZz0Sukf`_cC6>4Qc->}s=UVCK?Rpe{28MIB zr}&^^;H(jRwCR@fn^EVZlsZJP*7Sx8tLwC>5^1hT1kOJcXx+?bhjXlv~b?$zBk7E z>$qdwkMDeYt-0o!b8fIRYg#~0mbZE-;$SCiKwx_4cOmw|d34bw#3L^>A=u7m)%}{Q zmOsC#kl+?@M8NK26K4N?3#qbzAWbo^2JJrL6`<*3B3KO8@ovih!RVcP{*t7<$U$y@ z(?rQFpbns`)Gf8Sam^P0(z7?Hq4;U^#=rht>^vZVEmL&>FYQQ~7Bm|9i6RL)S#aqA zqW7ziSHN<|EzrJf?DlJby0ZzsRTy0W!T`K1qu?z3`J-g9X#V{t!f3&>ATbY^da&A4 zHd3LOdLJvwmBa2KjC>8*UJ~sTJ{<^uG!^x)&P4aO8PH>bMCU@=O^oY@hoxg}7$i}z zgAF2oJQyat{2epDLN-N4PyDdmK*1D&0TD%5BtF+yXTL9FpS3>;V9AZ_$hiVnID*ZR z+7u|Yx3TtsJWwbSkz&~=ga<8O?JHxGpURh=@QmxL+Xx)0Q($yN&ij?()$IOz=3BId z-bB$PGbl7&i)yj5?9!m+UKW%fkJL#Kd>nv=UsB?H$IVAU^@MZw^NnHeyAlI5qltgL zbQ6J5Ow)VUqYT6N=g2tleSR&yKl!um*)brA_Xv>j-CZpkrh(7JzGmVW>_KEn@V z9C^+btPr5+*e>;X&d;)OALYVl)(+Ud_|qBQqOJbCEkv#>g>_bojH}=!szP#d?8$Tm z&cVVe+RUIL01R}pE7VwSL8U%In~1OdPXcj-^50gyL7@MFUcR|^P0n@W1w`4$k9-NX zlP*tQ*{*GB4%F@}p&nNOoLDrS^Q$nBHY0v(62Wx66AU#baU|QPJ#w_>RJ#4;F)=%u)!IpxuzsfutxKT z;A`REzu-cy&iwfdOhdrYMhF-TY3!liML2`-wl0WV3W%Bk`A}<3{5^gx!9|cP@EHqn zp!Ww(z7BfI!kI}%zO*s>c#=h7bmjx{A}r0n_5YL3Dkh&thjpT?7t za*9Imz9SW|)uIUMD1k0RmY}1SeqcmRx>)!~qUZ}t&UfYA-c4PF;=duK++dzy8 zFVjZKGsm&fR|Q3F!Ni!9ql?Zq$eKQiT@WGX`5h;h_^)wi&iToWmt*X6b0I2MLt4da z_-%?g4_?Er)*&H>4L<)hMxT`BXiCd}fKn^a(GY}auU{;8kMB|Z=Wr9;!G>l0+}x=)6>(VwZfh=O2-Cv#I$ z27_t8={Ua9T@R1&skW)!Hq>Z}=vFOg;ZX#XKNJg{N8h=W7rO zVd1h?<|nUek;q+A`1$p@hx^jO2oQEXBK8xXcbhgCV1Xni^m~blN?4D~q9L+$E+4ta z8<1M@84&V77+i@9bG0q)+3=c)EPAx&k_WC1@s2yIMBi)dw0u&(2~b{NU!LPRT_1$2ICm{T@t-A(u<6`NancC3(3YQ(*d-+%PI<^QoNVbku1r6q73ou)tqFS z4~Eae#91%+Ko75HPiwX6awh9?rGehTyfV+dN(VrEL7rSVDuH~H?ZL=qcM~L&eo-5) z(}l&T5U++y9gJ0J$_}P0xfD#Xm6JOmdE6lB3G}j5=Jz+*E+3z|^{>xi%ti?oPXcWa zz-rzu?^`bQ{zB5?82;)7S76nZnd=cg*kAw;JvX`gpi78nkP3e@vl#XWU^Nx$$9ItPm23PtoFi##iU6q++h!ltMD;`3Hd@|+_2S9g!stzZ zlAJr04gh!N88yvBYzxpV#i`4nO8sWd$2~m8x;fnC08a9)QzwYdH?*zUAF1)&xqR(R z+G$V_aheFKi<*4(zs+ViVg&2Lvt%>p^6r@#@P!lz&&UV%{(yDh;>UcB=@$YC1j}oO^N_%5_*U@z zLg4ckFw(<<&N&EO>7-Xw3+gdOC0#x`-32fy&^%g-4&{n$uC9D|a+#xKot*{A>eqAC z^lS*aGBe=f_sfl6JqAiFFYb&iiNwU+)ibi4>f^4Pt2e>{;~`jv`8tjR$y?7gy|=&f z(U9U7@4tS1izZno`Z>n!AL^guj6Y7CRWmO`{8V_RU;JmA#pdeQW)D>0KducDo$<=f zUx@*+GAsk_8nBMy=!ucn=$&+OuKZNjjj-ZZj-PY$Yhb=#|J_15&7l@7!?26)O;h9Y z?ry~}=2P7MPlv4p`P46iW3wnFU|xx9EAt=)?328>{3nG4+g-44C+r6SonImdo$kA6 zU^g2e*2*=ai@ENOYt737uaV#g%_vYYFQ2+RRolR!x>`FAIP-@egQ6QhSYcXk1cSu2 zt=Lj~pk@@6qj~gPRQcWbnc%qq;Eh2VTeEhNCib9f27QYn!igN^Fz#J~1^ah{cvSca zWC+J(iy(K*!xR+*h=7|HBj(9Ad&{EF_Q2p0B(l>^Ax!}8nSCZh3HkxpIP`wod+%Y0 z+*gvmm;MwSalsUS^Dy=S5jTQTt=Z%`So-nfYQynEu|T%yrgv1q0y;)C--|k2+^cL@ z-F@hih%%yS*=9Y_JE$z6Y`|1K`55>^t-V$9VW=K|=`#bV3M!xyfWH--_;0zD3?8N< zXZSxQf%4zaK+o~~>XJnK(T*%@cN?++)|sq+&kKKRY9z=rn1Q-fr_+y-T(j+>@4X~#I>PkVBv zXgE7?1tsUcx2e8~K&;TovA-k4P zE#_Lo6u&gM+F53XADZyM9ci(|@E$i$%)hJ6l=`> za@)AnaD`HTg#N%J_=#()_jHTEK+Yn4GbOvYLN6giPt5X`i6jK1CEg6LEI)Uis;%Ee=~G*=PZe=)2^oX&Lq}@PWmmYvd5Q7 zlS3fXiW1emjC3hL{N`xbi*)Z#VToxUcLZ4)!&j(zZWEiv^_L@-B6kMq<^S1w^}eZo z`YdfQ{CdAZ7O;uH1p@+`0FZY6Rnu(9aRECAvh9klgDhfrL)B8`TGB6du$TBwD9z6b znBjP&e;z44Ew^Wtsj$4h#3xKejS7+jc~>`a2rh1)cy@(X?evyFj)U{ov3Q881t%=E zHuyOC>B%?s!@!yq05&|-44Gz0y@=Uav?8^q6~5Jssoz=;7S{mltEH$6>d%10*48Ug zuL%FWY2r6I(XZ+I{u!d?Lx44qtDWQ0dcrk=9T#rY20Z|+AX7*f%-Zdos%rXwH{1?D zWtuaJse@r4$dnRJmJIZMJGoj&4Q7X%l6G<8-Ap6{(84mlOOOszEQ#zJXbds5p)>Hf z(v>w5+dz`A+}fhjAW~azH(dtZ+5zj{&~`KXrY$)^Za`u-Ep4IrNN3_8l;5Zr+n zDrwsV{M5h|dcL!QfZWqdS(b%Z48HmvMTO^yynDqjcdvTrj#rn80=RCT=|bY3eRD$i ztcE)?!p6x5oW8h-2R99z($52dg<}T1%JyN~KT3SS-j*JJ3hY)AYklt@8>RgqrA)$Ew#~-ya@clf)Grz#Jz07M|X9F5kAUdeld- z83=pGfv?qg<(^3n-}%{g>~Z5WSk;Lx?!WvBLX+I01Hr>iEAlB8-~vKi;NID!bz|%JSs3LMNF~Hhg z0*1t>CXcTm6K_V%h@!@&N2VMu?VxS@Q{6^pPL)UGj0@l`Vp_;WiTW0(c!8Q6x&jBH zb!E2*7{aC@UP$`Q0KKtJRRxK*r1gCn=vLejgiyys*XA%^{fd!uVGO|&L3!1@f~J%3 zE&5S60zCML;>c*;&sV5kjWh1Lkc#y0ybBkIFQGiPBkqf1^XVhocgq+_B&Hv*{8XyB z)WNT)|NL=A9 zHg2z9aLqi*^ZAGxgS`?^sc%p-jQp+YEZ^F3*@uUmTF!pFc#S}f{gjwxkx9yY?kI!xwJRwk<-O2_GsS#5hRbh2%Lehq^(-=1t}(N17p4*cr0195zZ@2_!=yn zHN|96osE|vZVq9eh%8G%Y$r3H{9Cwf4(>C3RO7aR0=8gR2Lo}i0CNEQ4%5Qn1GOw4 zc6d`RBD3s|&vZl7f~l{p_&}P|aOe&y9zgUU+Ti8Tbf%PL@A2d3RqC#7nW$N%A+7EL z0Q5&1dHPHUkrOoOfKci5qdA=)K*^Xgi0?4Ej2%bEd{IDF8JC>Pzn?YexyKp+>$rB; znsJZ0V2hYKNHEtzuCfR_M+PW6#gN8)dV#h{maqCb=Jw&2!g>#CDx>Xs54$^bEXZus_%v*}C?f{Mla*iX;GLS_L}spVc-p zy9^-4eI0KSV8UZt>^c7 zq)ya6W6ROKhU=%*#RfeCrf7a53{YEpk&eIM=iPK6oLS!m7Sw}1+Iolmz`TxF=JV*? zmYBA=NmG!kiT2f2Mds6!z)V!^Wf(|>w*eWOW=RQ!LQNiZOA~!nb>aD7SMUU_4D)o+ zxfb;YrFBd(Z)-2VX;?VdD?;&gV@sm1#@f;IAwT{TeF|>xwt;3+HS>@#)i-2_cbszh zCaqib4YQokmGv)LGjdu{v?kUIA=OaHz2Khlw5P~>SaFY)T^}qH5(&O>6(DS%?k(By zRhzQu2SO?9S<`&n->!!$4lz|%0oi8$_4+sEZ%}_kD~7SAeq@Y_>d_|y%bTnR8a)w& zE9^JGLf`z8&P5c#q(tP)#(i)ySfk95^8Qi%mg9bgZ$9l!j2zXs07hR8d1qtT-V3K} zD&r&AT}YB1*cqI!iUSR9Ha@cejv)!4-UteR!>&Kd>0?>(ZJE?$SvV}e2AbRh7^CTl z)gbUpQl4CaR8@Jo2BN1ACIUFW8F)WiClP?@2$+b$Jr_y6DLy${WO6BhG`)eMrkgN7m*@3@xQO0fjaJa6JQQX zqxyWG0@#y-uLk6X2%bA7-iLmj9cC2TcLENSNM%n&;h~@Z$;&nb8~ngGPEmw(dOj(` zzl>2lqcA#=^h1LV-VkoDMnH$`Rmx&#KiJOzi!^YGJ***(*0%E^=F(f2FPy|QUakkO z1vK@5sG_IzyZ(CmX4KA?CW^)=zquvUExg<1&23PMIakB9fpc(yFmPw#g{=bC61-8& zGn4?z!XSPqp3bnbCpfu*QXuEf;_dz~m?6W{Z!imw>o*Z~^y|eppna*iH~V6gPfbzu z7yAuxhmt5)Z_OPNLI997xD{p(Tzj%bOwnK}%BsY7P48*5#(4`NqPN2BmE z9~a~o0=nIL&Xhn~iB=#oJ68HuV#vkgI>Hak$pB|>jG#og`I!D$XDk3LIxF%ZFBqtF z%3Z;42gU#XOetjtxOJGKaN(g+Dm+O9qqQa$doNxWbS}cOiez?bS$ctg#d4mavT9|k zQbg90KW%^fu>!;dfs1$vAu4LD5${c@RGtrWgZe`*ZIYk6q|$g_+>@6j4(23y9EJkl z8Gr|t&y{o`V542bUj&Ng4s{g2SYjRlz`(8bvqtS7WKjpJFJ{nq3NPQLMWf&#LOqr>#|!Al8TxDiaC_*3;0_yFKP)p$J=M% z8^H_C>w(LcsZ0FhF6>1A5qSDrcx5VATjR2v;Q zs~M8_9xKf{)q2Ksds;)EX#3uefgoA%$Yp1qw-4W$WIb6sA>*(n9a}vi zf-p+J+C6Plf6*q9(Q<~@UVTZVxAb-F%sZkCF^)=rr_qPONt5i1AfAJFav}bVZb|?G8Nn8X66{mj_Xs2bQQEh@-_lDzw6I9w^FBdGzk&!#G%`@PWN+ zv-aMde4+)Pw7e&i7fpWWI``LYFzq}2>7vO3H%@?ISp-QRVkECxZB|PIQrCQ5w`tZw zK!qEkK_rglPG6|jhuKMbyG|oV_U(wYAELAR`i?Wak_~p+;z0-_tQ&2rhX9#(gcBk`WeM0ChNX&(rzF(Iw{`%$irK#dg%L<&*%IAjO-7P3^aF=fTf zi;x4if7-GUmjj%WAUP3wQ0MjYeq#Rm7C#@?)Cj!~2?U?BSq1z_6jvbmZ<@%#p($Ko z!|NA^&zKRpAO?E3w=6oqv<#MlEqFRb!bgX&Y>Wwmzf?zVO*PIS7=O^<@5es+G4Iy7 zy{qZ#|Ec|1pJxX zq+gWgCCIBixy%IL4)Pog!&J~fr9)Ro_0cBl40K_ruW32ug?(tyysW9J5xaeYO2=#kJCPa zO8oJS1y@xmt;-R{BS08he}JXi0fs;Iq(;9(q|d@gM~@0^_-$Za|e49UZ5 zB6JWJ$C2q9EYX;=S(77#F9irK#urg zWJF0mHbJbi>0+=(eI921)xtAC+w6`Bl?7a6L_Z_Cd~mwc_6l2=uD0sMPB~U07?Y@PqF*)%kBPEjLl9hDGQ^dY&OgjndIp@M&lHR#?2iDfpaFpR5GyYqej#zocR0TeV|Kp z6Q#>w1~gu&rl%h>AJ(F|{#Gvmw7&>VzTLTQJenl8ptpq`hkIXw)J+InZ8&rxU zSVB8iZeg`fa1cR*{CuWU>3CpdL&s>LpmAz|J(EVQt%3`T9r#Fjf(^pVvsn>bz*z#u zD|K`zR)&a}ct_2^){3|ehorZPXaNP&D}Y#7yX=4?#pG#1c{dN2J?UwWxxE-gtXWC} zoeOv1GzK@18Cxo*?5WUl#aWt` zctrgNqe}sdE>OefT6ChsfV0Dh>$;%7^y$@aQEVgq_L>`K;sD-76EEy8;QNBt^44k| z_JdS#LieYD99j+tBr9US%ZK& zjEE$ts0{wW*mD#}$m*|=6%!8kB{l`QF}F2kIyB?cGD@|df20|Ab3C8^ZVK?_Z0et1 zrFhb$Kbs!fmj!Px6lDf#gXnjDgXFZw&;Fb=3Vf*VqBaXHiR0Bkm>;I^tG7J9l+Hwn zmRs7Xv_02I07-+)W`G5N{Pp(s88maehxxCLPH|Q9`#ges>S`0p=Bl%Q#Nk^>D<4@Q zf~1yjS(bT4Wb`3{)^)jcuu={9k{u9OQxEsMHs=^#_4Owvx&HCTPGm?zt2W~D3$Qcd zVARC?>CmvU8Vc59#}Xh13X?`Di+EiQ6mshP&eGo6rRN8AxGZ)S6Gr2Qc;X`<#)Qz4 zRUgQ{Y+f^4AI&a%Z|hVM-H5)7X)(P5-k?jy?XO3BY&I-*2GZSvpzR&iw5*uV=Lm{) z?#bx+4uiS_(snt1flQki?pgMe%x`sduxRPN1CwNceM^!dEQRcX4z%Jg)dFWDMZv2Y z1lsGo<52oK%YeN{cb`TGLFh?n#$caqh{#@{6e&+n8ZDW1rVE;Y9|v?2NQ{4z$yxZZ7Pn{SUz}k;(|#In&wlZh^ur2Q@-CH$D2Z)0&b(REK0Ja z4}e;lsJRN*v)9+>HSmY559#_^a4!O79p)1?Yas^GT{IC-!7-yXI)YX67Omv~Q|;TD ze}ZISp+KGrM*|Z4x%w+X&OgWs^Q!bVL-?+YdAZHyb-tv})7^xHsNfJm};U+?@Cpjab>LzPOfY7Tk2Q*gQv z7b0{N;R?E!R>+tjdTkIm2!N3X;;z&#r}O;YCFm!n=vgndpJfAVFY7C%xX^%ePq<@loWhZ@;mKFnE*uZ$Etyx zxH#cw)x32VRe~*o*?6Y*M0vmoY-kPy>uvai4iL+Z;68}(oR_>Bpow_pf0fdx5nPdTF9FFwwoCV#Wsm|Dgo~UB?VUXS8*z}$XTAZye&azvR*c7`%!4gL z2b#E!MO)ko{!?Lmrlw7`KSU4aOcP&l7s|_EIhzp$PUDj^g(YjO&%pUh((f%d$ZhnBp?3i_lr_A1-*lo+e+jj@WzN1N5*x5W(COaT2wVxF2{D$=-ZAve z$+6+2|4}IL78u>%%07D=&ENNuOMILNu*;x4g8Z`oNAWpb#IMS+f|&kOvk!wy0o9s4 z*7syPYh&-g$zrE{De#Hl_z^I2e0-6qRF-9BdLUhE?gx12DwYUv9cIN4;{yDKwWts!afldLK z*u56hC$YT$usnWkCxG%e{fioR+4fCfs8M4_BDNo#=pyDv2E=(drNV{AETQfDO$be` zZI?G?lw{@*uMe-WXFw;o*vA0y6}zY#B>@xg9FR^}P8-ZFj$ZDW=tM_Jx~mhuXu^BG zud7)kU)nNS1ZtSBvrZgdAA7tm)T)ngJ8_$F^E?|hS|4w6emUd&Z8x&GWE7Jc9<_3h zDdEcs33KO$!|Thch#P!Rr3kHrp~6`nW1dmTJ~^e|I)!91w=re$^5hg#Ms6f%dVBH- ze%XXi31cf;{+m9zC(j%mlt<|oEyfzCgO!xqbQEJAd4#-ap{TE4;??6LXfPwsb={Wv zG@H)ULec)Qs_$5HTIG9<1eFnh@s%{GX!1PlW9-<|?aXNXqPitJS$TCub zC|Qmu9f=~#LgnN!>%6RY{^taRJZnr&{f_`S4x8BdU4UN4t<^7Hl`CPtdzZwOEPnah z#rq70ce|MtV&y35MZUKG4*U39mh6Kyu3;^^h1hF0TVGOBy687+JB%m`t&S8#1MHf< zC4VQp>FjcL>?-Zy&a+nB{}m!aB%z?;QiBc=1vjGH>8@1N9364ORgS9?rpQ7Mj8FYW z;$eC-Xe0jXCMAlQ%glNggn@s1B9Xpr}r2zg*$mCUp7 z`#4N-&*fNjfan%gT}!Vcm6EExx843C)GIBin>ZGse>yF1nk2;ewW{EDy&o3&-jAX9 zYvF%~JN)-c_O;)Ac)Tw-CsN{kjJ)owVl5{ctQ_kfzP!_2@GA2=wEr16MNnYM8!NQW znZ`N&g5&fV2?X6Hh-O3qd&0smfa|OPK~ronn>=S!h?%@D-PqMJHg$r3LErJa)4U$# zpc;Ca`+RG!Ro|*+29qy^@DXYA3wvCm{D0oh`h?yTxne69hN_1DV5yxo{OxiT=DF=@ zw7HU#kc>Rzg}>J_C14Zovtl%A6IppahMj@yBIUlLstsVP!pTacB5^iqN`+1R64WM~~@A>sRuIi-$nk=Lx9 zxJ3+aie9c#Or%Ay$l8AO@Qr>8fs7-_)JaZT&;73bqr{}^VEo>%qyp3S zLE;$N!kWZZxpwixw)EA+5~u79cg^HjgImv@!j`aJ!ZuuspZgr4)| z-2E-X1*98Qvge~#gPylyhDxSn+tH>Zu^K~9Vu;-ytm@c!*N0)8{?td*ciUNX35 z!kg#^`xf~R(YE3wTI`TaI%U^xW;!L8vN{(UT+h$sHJb-FAEUc<_k7{p_F@Y0!UD({ zB9=6qGvg63XLS#cHQ^wBM{PYT^Lif$uuVag5dl>uBTM5tz;mD(w#K~XR>np#No&D{ zNiuz0)hP&alZTe@hq z)*iB`5%fuStg>TzcmI*}PnN7kq5E{jF}4oUrhN1ZHQB_-GhW6|7{gP;HywJi@DNrF zoIqWp$3~1AL^$!SCC#-tUHz}m29Uf}zdLMTNk&E|iljBtMqRknoU!dTid?S@DEw1? zt*M}8nVepRnN_dSu(oV7Wrf^17K2bbuDZ<-q$#>;xV1#2cWB>$#;bABk>Njm90@Aq zPRc6RcB6nLiFt8)KcfHF`>Oc4jeEpj2jQ)?hon2+{IIr~eqMP%f3#2z@&nY7@Y2gD*VLT=y*qB^b0T>pmCRA4h= z_T!oVD7nYQp+|i{YP^uJ;)l-QAkn>{>E1s(2;(Q-DOOqlsdH#FrzSi{~=bX@a_f#2Dt6z1Oz=XiVjYQqS zBj?^m7&B53_$F7$m2Zw$(iTLe$UgqKc;`og4=H9Y;OfUkL=H1p$#T3iU$IAjhn|s2 zZ!Ax|=T8tbi;sZonWX=$cjjztfM8Y#ocF{Up*G{U3C}a<0!I4IZJ7O-9JStItoLnU zJ??ePZ{6m(|Ft3QB=QsT_uin2ogoWfff6pYP#k16bH*o9z9uSy6bva07?Hb9ec;lg zpSh73li9<9ro-)q6^Q7&c=1;h!o9D9+cYULK!3sY+aob63p?WvR&z_6(a^4{X;xB?X>Y^aD#y4k#?^pI11`{99@i>>ay2{t12r6^^R}NrRvp8Q z?@>knxt5rY+;lKKI}5aw1O8kb!+F~5gX_inWc!pIh6{6PM}lho*YCFddtQtUlq=V9 zqs3SR6paZ?)X%Tjd?O&(N&WD<;sw49R?n_%;y{bN@E@h(k(&+$=VQM^ZJll_d}lX) z%jUO`HPfx{1X0vK3Bt^IKM5VNe;s=!Z)-l}qI30eXsqAo3G2)@=<$-mjW_G@V!tzH zpRdieAef+pp8eh@9IFfG)JncM-AsaquU>Xp{^0V?9fng|((e?tv@L}K(M%MJQT;_4 zF1wPebrP9*q1BmlIxAG&o$$P%q9*B2AZ|mr{(%D=(xMeQ#)E3_*;$ek{$03^tPh+% zi!EBMiDgaSv<+!scf9F8wY^~1cbe*G^#U29zO}mpaWn9%bK{>dggEEidgYV@$R{Z{ zbU0oTw3oxa7fsmc2G+$fkAEG1R#=ln%j&0s3{G064V!6;&el$%d%Jg4->z(r3PK|T znXML7E_t?AkI$oF5iyqW7d#2<8jT#cPpHRv(24vDJ(4`@C(|`)9AOB=-?aomDG%?b z6`~dN3&YuSwe}I0>{I~%T*p1(+xF)eLLuU=r8KF-tW_l%98goPI4@t(0tw6^g|Em? z1?2B^;q&Gf?9cw~3xiLD`6GH|hs4LPsjAv*4*`~WebWzo^#bX8STub|w-oIG@)?#f zO#c7YywX4C7f{uB4`oGEv^#A#nUh$=SaR!RN~+#bG4E~m33ckEyZ2l$k@?;GB|8%!MSp?Ma(&{$*<5&PM>KUVe-7KHYs5<9u3%zZWsuDG;u_3GBLU?-Q&Wquq{ z$hwLHl%TFN6>{Snmibq!|8`PTM^kNk_F5gT=@Ys$hW?N>bLz-MVPN{C;2yCe?JBv- ze*CNRscXeAe|DaOZ;G56%BZ(wduRtPVjT0fUQE@#5ZPl!kDiTsSmEc)aj0xseQk?U zo)kME!y@rm!ORxzJh*Wdv+5+5lAI&3SaqPAZHCn5{JNrp-oQdTj2EF5b1!~Rw&(O; zRRwfS*YOTB@O(Gk+4dVV+n8+UNKyN(VUflwRZS(qosjm=CAWrOpR+OH6|Ep`Sxc*m z{hhA9?MSBdf^;Unx*%ni3{fwC0mnRqu9pmX8g>huD}nt^ z0j)Dxm)|NXK}ls1N!&^)!P++H{9cguc14KX8M4--O}ohl>AK6dxIH4C{^ zrqDBoEdLF1C_RS7hW}`W-R}m-r%pY_nP0$Kp-;26!4u2!Z>eJ9d?3JPLlM!rqA$ zL5A;s*`_nygSn(>Xw`$Pz|a0M)#{xEG*49kAoBhR1BaT16-I4$7!lFd(!a#il#Tx& zJ)XH0luI_?{A=FxUr&EcZO8i9WYQU1q1#*a@ewD<4OIBCE9DHPd)uMk z@B$A)I&gD_;(g^V68d;dNh}Bo`j{D1YD00qSCeY(k}DFStpLa)`eVwBLG@%1Je$DO z=D_dnFJHJ?ROgK~q|JEH*mKjS`8WM!ET5i;+Y*8z zgO{Q!hUUz??@D(ATu2QR`5rmtFtEohT7}Yi3@v`ebnAadE4rzs{5#y8vxRL+Fc$tz zN5F~%!OOkGA6>>6Z7Y*&Y+?X1+`<-$d-7xEl804?Lk)Q=(uw5WIS?By-Jrn6R1IVO z%poGDZN7vD;wN_Ne%zt($JRsyDts?upDnJNw_+`YOT7i-_;E0tW1jNJyxk~bsTm8q z7=wu)W$Gkvm%(GKbOp<#-Bq7PwArD7c)BRPUSaDY;Lf5HW7=)nO|&dXo$bSp0^Uhze}Q8?(pmHtPqm7Is<9-aI0$$B*1djVpuU?*O+>lBDWQM^fErA9F6EzEq9%O>{;5 ztw6wS|)7Ye`#^f8@8Ju|zktw+O>sBdfktWS?XO2hf!S$9%JpJzcB zv#}`X0ng5tDOU*4e4zJ7GtEyq>&`^dnzBLkd+Z6nsaVM?DsSiQe7&-Y+Hn<{Ew5sc*k)?pVDj?uV;iShkzA zLhPK0N6?Rju|D;Wl_NsVY`e<3$=;jWkm|igW-1oC2?d`Ah6pD0-4O!#*dN0z;@4ZQ z*tKc^X|&e1ihMm^I*IuEhDPRcTYY>0!$oq&?qq0{^nbgMws~B@ZR!@ex3%>w0N1Tu za}xslwSSm3g4rGKR+>dhSje5#oV@tAR`z3RPEy&5&QAQXAl-IEK;6I7n*b*^=@m{zn8}=(9-x~tB}x&-*ZvaySD#M7XdmGTh;=-3~B@|a?_gc(XlN~Q#1R~u;1pN zVZz0()9^LQv)$-W>YrB76R$hig9J9E8$=R3b|V0#BblyjsVpI?gHHH~7D#*1Us~Eq zn#Bkn_w!hb=Lk4+>`xtG2Y8%Rj=9gb!`h~H)?R=dlkYQ_KoD%<=^5)&bgY2GfUv$< z!gOlwAVk6D?J8<68a?sSs{CMoC1M%^s$9)uf_WPFGvwu6I7T(5*<-?eV#i_`^~jXc zq3eFi|59UYg;8W2tYSQswHH5oTk7Zm9ubZ}W~1Cq-K6v^ z0ID3@wt@}7YE}JYs1NiGe!*RT@b>L!;CDAb`b99kWV}E`nxQW${g!kx^o584v<7ES zDdHW$qEdW_v+=mbST1Ika@Nrp;U8Np3GAOAo16p1XDwLH6LgKdsyq6%R0On7cuUR# zrlPmHle&S2Bc^AXkZdGbXz@!WW6t6z?!#>1m8nF)(j_#rXvW!<{@B*HF1$Kgn1_56QZbPIR zx;;UGJD3ztlnXHjXu^`g0}rz>Q^>yZtr^;SV{7NghZfVk`4?vMFK719q0S3Tuvtnl z*ZiU$hW!Jv8l-4*=>T$`uT1pT&f+dNFIaXIT+Yjk>fip3rL7hWZp}>>@R~juq%gJS z$5go%@w;>jiLFB(7bi-Ti+5a7f)c?hf6iqg z7^fY|V*Z>rS$)&tGb9jK8r3tIj)SP_y_fFkpGYNkCthd0TMWn=8z-!(lRF%ggj&+Y)bpj+2 z$OwC@s)htH8*nxsw@u_5v&aH9m+TK#dMtz>=fP~M!Oh9c`;%rA7|HXRJZ}lYvc*7l?5#;-niJ=$LJPeo;}s zpl@r0ao=9HDIDOZVe<~hj}h!Zv2Blh+z$ukyo@!dIpkdc=SiM9uKk*X@uz=vNNciZ zFe2osfa{q7?5qQ@v#XbIkwn~}YxHt`g;bppbPm&Z$v#`cz|uBv9|cK&vcFg7P2O%s zT$^8e->e52!aH3#k#=S*VkKSe@o;~(HNP*pb!)kXbK?4}IbYNXQjU#=y7rUyMGM^2 z;GI}BQXg{57v^=g`lhj9i2j$JhU)`+VFi<@;8V-0$abinE$@fPJsXdnhJ*{U3muMo z`-+-ZjdJOJu*Si5ZZl&5FIY=y7Ju{QEy)6|tWcg@uNP_JE>#Qyfz|-rxEf9g!9x+* zpuiTt^=9}@*j-b{mF3V{{uIX zV|O}sp~OE+%FJE|Oa1;p5GUG@d6^2Rcpcdj1jwd?7eFsKDxNZY{&M;l5o~&W2y`f| zH<+bm@4+%amnXY_w1|fO2h~>w*OZDlS0e?RpxymEzQ=Q0Pz70J4CW^m$&zMnI+R<+ zS3NQwviM_VS0=s~J{*!cqr_9~N!v6Wfl6v>Fvp5&Z7e1k~Lh~&rPC5<&{yLq6#B--y7ZiA%Qbv zf5Uc?W`k*1YV6f~q5wCmH4Q0er;{~?<|$&p7kE`S^k3{{ltE`EaoX--G69zw6VX#9 z7fD^r`2wh4In}C{hba%@yic{tFN%$fSumnMd_deLZs#dIME_{XiRpRijzM$$BIiR{ z@eC&R?^tQjuSTr{q%?IK`_uPOisY4MWvl8JcJ~vpuIlyt$=5CI-uhh!L~y4M_)@g{ zw+~&(KFebl^xpJhY0sc-1StL|RoG||w{?QyJ+F8e=LR#BPB$MDnP$cKZF>GYg1xV3 zo5AGk@}yWja})eey>4N_>XruX>Vn6?|L+^kG4Z;|GWP?~Me9jj+iwSahT*1;cS=n( zsooXI!IFs#NIl1y4H4>q=l%XyY6@V*fHVLJjOw`A(MNcOb^4ofOj$}xN;jrie=Z9A zM2o4o=x!4EySz~@&VVPq>@F{b3&vSl1p_K2@V7>(^}`u7P2JwB=Z)`bW@L>KUWQ9) z2tjjPh@5WD0)i$*7xcC=04Zu$$Az5Z!p332=eevKsm_=f2~PK5Y15WI>`_kx4t0+@ z##I?bp|D3tCTWA{;dRp#n}&5M`J#n({F4+&r2MOm7TfRCiTy})M>x; z;S1YZKnCOxRm~Tq{XPvP!Mxh_)Bn~PT*GKK$m)F1wie3Oru$q3Nc-JdDkN#v1X`gE zqw~CvY&R}{L88VB`1T#58kfoE(vk7+(DV4lyWFyWQm~PzY}t_KHd4mN7au=4ZFSaL1$!ue7&WC1lo?%mUmLjEt{?(#q zuRGQm4@<23-DizNTwRtA#=t2(P>}oIi~VxAyZo3E;VI_7uEpkQU};_Zcy^nN^Czv* zr2VnV;N>sdJ5dD5RW&g8Sc})pOROqR1@DU*^C-PdC_B)N6?JcwkFz0#fKh#~qGMs_ z%wg{%WSwWNWKo+LYE=h+)u31ASo=)}1zjN&t5@m3ESizWlBc6@KB#Yc4U_mt zG9%d8%Df-{@22LK=W-fS8-viwwfFDLk@uIaodfT}qScfgQd+Jqoxw)aMkWSlPq0Wte~N+wZHxS4k*}YaJ|NWsE2z{nCo2BcV5dxt-M_qv zOrMR?&HX_Vt69ny-}*xu^^Ci8)l$az(`M$7C=L3vK@1pD^;x6v_#X8f{8-`xpZ}vv z2ACiNIdNKh4Z3tARHH14`p1OZdmDN z4rAwB&06+^H6ZrKlie?jfYY?}Ym|sZv%_#4$No*iF6ICp0OPcy5PwnE3t@w(;7+Ua zZXVJ%S@JdbnIAuG5T6RoLLT4j;w38;%F|dnB(n8#bj zahV%#;>K>ZewGmDUMGCK2q773)q|0&kj(?pQ%InM)x~%ED4rBmSsHanxpMM=1`h9^ zBjGH~6#?`w80EOq`e|ypu~e`4GhdTukC7k=pYA+j`#r3I6R_|OrtoI}*39=`SealDj)Zmzn(?T-Rg>^n379z)SZHu)=gPPu{0(V;XQ77}6tPEf9Yr^+h-9avK zxrO^~2X4B2F_VoVe8}%mX&h3zQ&n}y+f)ZVQB1+At-5-QH{Ho2A z!yI>zI4mJPfGo$wE@^Yf;EAd-aV!m+9K7imDdwlFcQcDl^AG4U!cQz@7++mCu8>4Y z=j9YS;uI3edd7}lmS6x$HDOO;0QK&vX+>9f&aYaj>S{s%hpYGSr}F>fhmW0I$Syla z$j;2D>`m6GY_iHuN+_i4IM#8D%rZ(wlppxz2UH z-p|)_UF~nCHRYCcWmlfW?vNiUo_VZ6?e;|2^P-o{zJlv){`9n8N8RwNH^*-{rovjg zi9%Q|{X~RXO#IQ!_L(2Hbj0>1dp9)O*Ee8@L%DW*hTrI(;8{CS5G0gb9k=!$ls49~ z0w_Hn?C)=0-Hmas?BCT$g8$X`Rww;?{7BcmW7r#WN1}^Rq$4|8gko1G{GTN`F^x% z@m){H@y9L4o%tzN{i2%=?s;lOW+fFGXpyU8Jw-XE&dGbm7lMJnxk2j$@zmGrbbsr# zi4i4z!DgD~DRhw!RkqZF&SmEoTM!}2@|UCFu4^gY{rdmG*gis5b<88bU!8T?efOPU zs2J54j;C$t>d1GqAAQNTd-t1Ca8>`e`@=XeC`$)dev=#1c7_~K@+8;yDVD&3e}Ccn-RyP`I@lr7jVPqo^4UwQKS8~{w% zJ&*#7OOh}_d&QRy!ze@UN!d#pN_;bHPvFDdNkkyb+N}4VK4iURyLF!Sq@(u^n@6&> znN*raX0>@=JeAOGGev$lW_gcdJf7xa2l?%lV!JnqDGRMhBD2Yjh5@i_0pSOv2#%*& z^WvZW{hjd9DD%pWxd}SOx-)upYwLkSBugMMIdxI#1~6@|Id(W^?Zr6y`ucWSqh z_^>Q)boB3R0^^1~npoNxC?AEniSC%dG`pCTjgWveQiSF2tC5y)M7+c9Ia7mk#UB+`Wsc!Vv9B6%olTb!{bTh)ypg(FX6@ zN0;q9nc9Pi*C})~9OC|>i&dZRU@pNcE8!Ly3P!jq17flG=%wy;0d~*_Gn1i@={vcKWzT>R;7+uXbI3VDIbiLLaI7!f~s3VM<`uiTmKR7 zST1j);ZkMqUf&Eq6!1F4e7a?ZMcS2#;NS=lGzDg*sp#yKC1q%?vvi;_9F6iynNpd8 zdpstaRyLTe5Mbg7;&$@^$ghHTz9erp5AoJ~A@0kokHa@)lJ`6;A7xQ75IQ04WPY+Q z1-r|vwbFYzhGF%)UDJOke)JRnNj_>w_RIs=2!IV7 zpLDS|7wYtBt&_VcR@^)DRcW-@_?FBDTrqJ|h)`{wHDrapeP zzf}?;p*8%r_a(cOqPw?uk0S%HMofXrhf=;xqWLq6 z-69J8FtcEqUEByWE~UgfG}T5>;ShKK{af=T@LOg@OmMS&ml>Yj`Q;!RSaaJCQ60(Sz@zy8()&{%%d#vLx4vdk|f^G5@?5 zOE$L;-_MzCU4K7wGl7`+N>=Lj18O?p;FyKZ50E~3FHpwBsUz&Bf5r6-Oujetf_jCg z7T^cM#Mc~ z6Dx6#^D5M5btD6j|tBYagx0=yB?rMH0gS|5Ia!h*F-G6k{jkT=! zn$G(Z)I4nw*CskM!^U|F6fI$upMS5^|AE=;woiRwVAc0UAUNQcLlz+MB4K?hr-UmR zoX$MBE^4hj<>+1lKT*%|+H5gRC{V@0mWOXnpQ}AXT{)8f6IA;GC%HJeWzjS-Q@oc| z@8&^EabgDdfX7-@;K#;}4pbf{Xp_jVP4e z${b7#OCa#=OE$B{KBq}lG<=x{>|ztg)POxl&1oWWxurQ4KtiuEFl6!sL_0bf}ITt*4asqBng9K4%bR^&Lwi zO7g?EC9zvek%LBW-o77n1ZF8ig96i=@=K8-!XJ>U=7Td?YY@aFM>?roDwuv`j9JmI z`P7P@TYG#bKzmP(Jhb*Z!LTI}+P_cNsP6iq^mxRI-HZ)Sx0MkmL8_cIzos7wV#vmWny z>yi#Uk8EAE0=+$34>9oHU_l%XoYl3xV;rh0{F3a6NF{iF2yon{kO0TmX6^ek6j>F1 zD}2w;A62AXsUAUX%r3>36#9eh=N53;E92y=nF=UvzJBVB=gv0ouI0y^J2mI3$9ap% z%o8o<%RHIod#s#@2)#d5UR@Q(FRC>}>|Q_tf}HZsTVpAY*D_W%?k8CnI7EA@El+r} z{HSnGE@mI26O<^Lkngp+yj;9kUE%dXA)>$;ljR(G&#;f9IWq5`q^FBNiShbFR z5%%2gUx-CH;(8TS{LW~bi*ss%hbS6J5=8##wiV_--=Gf2S96tShH;52-I291E7x3Q zh_il`Z5$1jEGz1Rt!7U^e5bJwbxpVgDDbih^%f6IVX?akZj@qP$`_FJb;1*GW_c zJ|1Pi{d)giitYl-)-(yC#9LAa2Gyrj$}RB%q=)cg5K3_Jeyht&`@__if7y zk|aWb)`lZSbU<$DC+(F6MONR7mWij$Vd58<-L5b(qW)Pb`*qxH$aRd;?chik>pLIO z?$VxAPp9(WEqG9=^PX>nq#EB=@>uR#l&Hr&ZstGNr=v3ZyU=FJ@T12Wm!XgIRWLn<)@YVue+k4v17c4OZv*f}6($dpGFN z{?aI->vgy9zQd4e%u!9LTTR--PY8rdsZd#-;*HG}TfGn_lay;ji1)?TneY`0$4lQ< z4>~&3tL3e^f6Vl?q)@jr)_GewGTWX6BNIa!1?mIo2Qj^W9C-USx!uUM&l4+GP(l$G zqe{zZ&Yik-ED-G!W%e3F?iFowbbB_mB7X#MRd(YKXNR&!W%qq=&To{jCjpTW<7x3I1pY?QS9>klj#c>3>eRNuCmH^gWKa%sV{E^|M`dBm+7v6-QW{5rH-(k*8{2RL64sn ziin1JcY()RN$;%zFwOwyUvVdv^o6s zN5qpgf4B6VDOwYnk-XYIXmiPl&9l$r8Mx}5l8H_(h|K+Zh){h!VUgpuTO{+1bSV$v zuYY*(J|j2~?!eAHpwHETKL6y%oU}kz(Nj-Or$UZh`^~>GD8adgrHBc6#oY2kUP4$BTTkag_%G?N;~s-|M(1DcIJpFknxspm zx5JOSrLL2bYDQuZD7H>bi7?XtXq0eTU<>KwZB5Kg6k1Y<&K)j(TQ_0vo9BO4Cbd+A zaI=vqzgyw7`e)QF*w%te)pP0^n5rx97w(Lj-MD0g6zp8BV@(%Erl?JeL(IYH1tx@bUt?;)$27PG0 zUleCzau~uxHGokPPSfN4(3;>R6KtwY)?UwNac(b%LbW;Qc?HdI@yt_F#Ot{A!qQ|& zD$Fem`)6H36%C#^Y9o6uM?gsOM;&?QQkLKn**vUqFgT>H7-|uHo!;PE{KfIMbY|H_ zL-3I`PVf$ZAIo}XxX$VY@YTAYd}suD@1j23UDCrTju zlI){Qk~3Vq;SmxGIvu-=4Keq)6+A}rC0`ue&m4PqW#m!T8*6zh(@q!K%v>@t&-}US zfAQis56^cm$7n4zZKc7f6Lf4Joms~GNDU4s4Vep{t)in%3X=$Pwo8}m=Pcc?>=Krr zp~!wf+v#*m^TtuvN7AFBz56K;D^FPB$M$#k3t_o_-9dyKcx=3nP(z(`>4S6OGgx`w zng1n1j30$ycQ45eeVoo$0oMo2vJ){HQyA}*P21gKEksVP5xSs2iz-(x)mg`)k7)D- z7Jjp({bAayUjZ&(NJ7+7Yf!K-suMjj21B3$?_?%iV!q9mgD-Q}8{I!Rpz(R*C%%4n zt*jhYlOc}T>>~=njlgrHKpLzR`eW=u4_DWGp!S=_>4^>WxYDDhlcbArRVH38WiMrd ztmd>KMG{6ir>$qzSCG23@faHhE@29#kcwskv-Ztp&zy6u6DO#wT13){D(cV6yx3RG zTx`9C=L_udBMSDdKS9VK+yh&}DQDKQK~(R%!>s3sCi$uEG5M~|M1G;r7JQ`22N&J# z$B@|jmtJBJJ?;CZU3KTyWZ#eC_zMP54rgGMm}pMymOl4+VR@_C z3m1Q1hIV>VDPNin%qKy1P?8ZEw)6z3THt=)g8xyKJ+Pa@{|@7C%tJ(|am`Dj>C+F>eDt&s)Aep2BL?Rq zoD>X^xumJ74DajD)1iI8WXN0$P=IsCg_PaGvXm5|oc_^wHaN+BJ$~a-#?jm$zYsWq zI)=lgyNfXv^OOF`oCI-k7Pg|0yrF{27m zEkiFkvQ(^=Kq3N$eE?;G7rQDn5G-olL3wQVQ`3szOfr;z{=Ms%4@A+I#d$uMWN^LC z@D?i3BT5@|S~RjflAoB-zpTLk(iKN#QXu9JHkXv|=4&fQ)lSXdKa`-t)1595h$BFG zBtZEio34(z6*-E26Dg3-Z{s#g&VUQJd(t4IFZSGy1}(7Z)w6T`Vb`8ighOZxrZ|vH zi}wRumR^7j@(R%Db<~rb`st#k*x^JXFRPM8dL$|q#_*Zly9#jdWt07BUS5dwvs{sZ z9vV7BIL}92_uf(aoDIgV+iRz%irfO9MH}y@aQhFy>@ z^n2~5d``Ap*wm7^435Z+tv5AbJUdPU;wcqm0+~G6!@a$^lx{pr0vwX7c*5#Q@KM^u zfTiU;E{d03(TRh|`8|(*7Y0+N5{KEiBi@?kKsJ4~lgP8{{(CC~oa( zixz)_5z+>CZL!+|oLEI>d@kgyWeW<&B#z4$!uMDUjx=6X#mz{=CGU4(H?>?Ec3I%{ zk>NB_h%o_!DOj}n8xO`WgzWUu0R^BJ3IUuLvw)!0rbQ8E3GguaWhFQU2TlHdb*W+c zO+M488ipA#6I{ux0;7~1Y^i{lL$Wuc%iS7`(&XxZ>xg&%e#PL5bfw%TVF850-SDr1 z-#5skEVplXo6*O~b<3|^kWic|m ze=OwvXW(QW5mNyf^pE9U`orkJ5MDIK33B6E^$T7 z+G9!FT}Mc)&4&>e$Jm2^*zDu@eVK18H?EE2*uh#*KI)oNylm>D92~wYAm?r318nBM zoqneezdh02bSf2|qn>@N)o&?8t{k6^PfyD}+v|W`b3cy#r==26&X;nG=?74DnXTQ) zgt^{cbk<#G^=E9#M+MelE_F1S8A5f<#-ii>iuQ%lfR&&_`)DA#B7wx@LXniZaS!eSOVXCN;$s$@!Q0Q!7)!NapKH<~qQ-soO2n z0YK^}WCg*%a+?WVGMYInC{Gd5E)CAGXisa8EtjHLi4hXMC5n6QWiA&>*<4BgjH&q9&4*h#MRZ z(mVH6>zxNsy~81(cwR*vY7`rzrLsEooF%NRxjACp?Mq@c^E8S~3Am|NVchG+4Vhq( zZe18o)@Nea^zDtJxNGZPb?ONHgQEm0wn(Zl`in|T$}7&)N;gM0H=s$!C+-ZPN=!@G zz=^+oiI@iD9U!DFvsNS=-2u_(N2{gmRyi zE>ekt!@i=FR8R&^WQ;HSRCDTcnNL@T) zT)D4bX%oA@TD6KEeeNW%^I>Lx&cEUQ2koMpny(l<0*Bum><&{A>$5Ly8x(z1P7_ZT zl=BY=^PHWX*V!iGiZSPR?e^jX#*Imxl68J9ID#{@u?cxohAj}!0**pub$@-)QU|$b z%e#vr&TqwZQ>_tW`Nb3o-^Uhe&FXDbjW36Q;&89$9y^Khl|Qe~mX&022F^$!;2Xpg zQ5LB8Hyh40Q6Ol5tph>$XO$beK;X0JP7?$sXS#9hzYAepl^2r=M)^*jF$~)-Db;~SR}+$ z5R=j%LLsM{=X`G$98;jZz8!6{(tLgzasi-9SSwlIsyEd6-pKq_aN=TsK=CW8QH7oslN9Eq{7Egi zkdeSkv;Pm?3LP738S~B|+JC<-zI2zaC#GG}`BVYA;F4HL?N;xjV#EXyBqgzJBDZ)h zc9%@y3vH&)%yQNyI=B9TY@&_I4iVzIr3cDLs$?isMj`V9Tth^5=$w>SMT^gn)jr~+*3EDb$r12C}|M%#a!5t%>Q&yWpQrRRc`|s(xbh=;u zNz&5*K`HXNF2hP=2%X-cEXXPB-b!>0Y5v|yIcN1)irrKSxu!{8GfHJjkIc-IrIT04 zl(OMRxP@ewA&_j)Q$L_I&!ax1+BK;nJPobZSznRun$n zhm<4M9SUCZl^`H9NZ1t4gB0MSUA{L7_a&SJFJgGLsSjEcCXu||{0OgP&ID(mJT#aV z&;{z+OU5vq9F;4-#b47-d_1mXr=+blOH+DNhN^ZsRp{)8Vp8rt5kLgNf1R~FnTSCU ze;9Z&hv`eqxnA8Vnm>LW9{bI5s^G6hiL>iv!eR%m!O@zG()FtG@3$*!hFiX@ z#Mlrj;H}BkqGrxZn5zT=;_~zBrB{aVTqh_IM~H$TicfOgz>+{5URwC5UDF^&cm~VY zt2@gtXh>b^o9F|wW43lPg@8F(lKN$)!UPta7=ME39gImR4@8{_mI*9mOE60l*L*z%2z1!=@4@hK-ev_+0YqxP`4zrU^UB2x+@-16_AULhzxQ4tN@7bsmT|oxa_Fjn zsB*V=KtCMPJzSLx3W2PSy*q-}WC}-I)LECXyDV7R)HbVUN&RKnx6I~jQoiy+#KqBS z*|d5-iVwVr1Sp550Y*ANcr9sm~BWk?mw` zP{E4Rn?6=`h)LYpBjF(m<;qFEEUcfHOu(B~m$R;`^1jPfCqm6^CMxNqixO;a#z^>Z zU2oQz3VZ={3r@(-S?SH(NbbH1pgtubVvTl#<2`?0`X``l!}&#n=%WuS4k?Uqb|$W8 zdYyV)7^JS}qn(zg!X9jw1fLo;B!R$Czj-ua-ToaddiHmW0CP{4D ze1tmN!^S%Yuv&)!^3r$6oXc;Vu6YxQ-CmrJNcu8&dR#ClP`Q)KLP1NiaQNwl2#>Cg z3MEA8r(}+Mt~o5v%H0x=I&q8VLU)PQ#KWVqH_v=+MPo5`AvLWwLG^t$59?aDI#>Nr zL_Oo@wYUZU8WxX!@BJ4qpIJt$r`g9$9X^fZsa4j6tOUTR5P^67veC{Go81ngSU=D@!uPRd#0E|FXHa6p50^Y ziae^DVkOhCGu353N2AFT?PMNH)UZ5ux4!Y+Q1FUcz)8uUVqZPRT*_qoGw${zZW40_ zbK3S1#-@fEmZ=m~!it8%)LF{$Tss+o`>G63%cEbC!7#G3_C6 zlH0%2YGzjc@Nz@Z>Y1cvD|Eayvq%j?=zL2~|$sJ)TM#UY~yPL;jU|0e1K0kh+5s(wz zc&&A)uMsRrpsQuvt<+#(amjO$1z*8zrx}~z>+-L>b}%&K_=e;($uJrdUAJe5U}=vx zLh8784<`nuNoERum2NF%C+bgax`7Zhl=^;V?DucYu^k`+yl-J0=MqYA!yWM8gn7!1;#rnr&McLQg?9KPc8 zId2`~>rw#xhTEgU;nJBuM1}%mmDz=eJmlPCWItQ1LyKIe!ilxz_kzLLZA5M8zT{k0 zjji~J?x7)BGiVwW(`h2s~a6#29{q)WUH4ZCu z2pS4Nj7|Q40U~2gs8_D@i*$#}+UmYwa2i%ZMa`WnlXec9giBnr)lNLEeC-^|@7`CF zuZK_|M+J0B864^kRdI`>*yABcaoRLgl4_N6OTEXIwZbyrl8pk{P_Ew$0alOgBS2TbOp67bj!;{xJvsFG=GEb1L^U z1XL^l2uwZeiYq+5$H&KSVoN%3R<61Cc)kV9S%Rj5t(P^85{-(F{gW)6#<+ zAdW3wD>RgnWJqPULmFmK2~4b2i40MZTEqyI=37qtt_W|8uY%>DiMmsHIJ8n9Pl9tO z*Bs|bQcJU23Wob!jlVZPhy1KOVaguc6yNmzvdPH#Hm9z=SBH8+5fbF?XW(ap9u5#3 zK8yNnG1y$o>5fi>oI~@gb=*29eKD!m2sL-FE_{BFYR4tpAAe3r7>TZ>gH=2=b>6PU zg%fg#9%c$W8Td$Ta|D;^4)F=MCzHteb^J0q_L!_Bah-?qJu=E|R-rU@cwmB;7 z<+7%y%=-~=Cs{Zi7C??lb_&)7JwXW|T$u!nn3Z?=#%#SO(CfJD#T1AFj%hM#46_yl z8aaekn}C=sA|@}Fu{H4>3W2UJCsgOxDx)4rv}yNmbjJX6Y?0F(qdhmUd1CqzPy(9B zqk9-s4x7FMu5(2+sct&?L_V_9lyI~__QM0a zhry`23E^XiV>;Md?=ftAZj@h0ZCsX2KX}fk;}!?|+BbQNg0o|^210W;ysz4o zSYNEzI%%VtcpAbqz*bhO6C-2p%W>G0omR`~_O+q%zNg@z6b<=@ut3JP)FL7pZ?_6Qeg-)`k>j`IpKSm&T@cmi>#ET#2fi#>Q^=%hoCOy#HH` zH;_s1H^ps?-8$N=xmnnYzJIC7#ebm>4`!DmL`37_EO;B>9$Dtyfwfi=(dO?PDq!FP z2INU`d$t7xeF-HuPD!K;kQD%$N=U%y;?G{nm%SWxs=qAi2s|)D;DQTSg5I6?OLMaA zhJbI$_K!<*M^6wu`)jF@M_l-OT~;B_OurS?>C&=b2xStoi!FvE1D4d_OagT$< z5c>7btoruB`x$5P$2JD?%l*cq2PYo+dG8cl)yP|UBH7RCr%AZm=nNJ=wZ>FbnH-9R zpR`FZiQ*PVkAkuK&*9h=_`~W%E_1SH6Q2vbh90MPqo>3eG@v$$x6EXcYt2nt$Ox6R zC@`VcmD9*g1;Ge@KFu4avKwd$S__0)jkQ8p!Kg4F_-u$uAbNvBn1FFof37$JiMXIN zlO6mWN)%|bE{#tQT1PIT7?C+awZcMX>gCi$ati62Ho<|PrjBPJ(3)#KytJc{h$DQ! zj^cewSJ77EE?Bl8Po-_{)$l#RKd06W%*rT7EM3Y+`3?Pb^ajzZ$SxIOLYA`>DKD3~ zaahCm?qY`0bq_q14tpT+9+W zN<|HAJ)1Rnuci?E5@U-Kx!M`xW3LB9$OR4^wpf3{y}BOk-KK&&0MGObV7~slhBsuM zCyNMMiI{2(r^)FwFLsIl{5~@|!CoSmV0Gso5%ekTlYKU;?b$o$a!jI7AOZm5{JjB* zrDg>IHpJ}8HTO+^QMu(l_}~)P3v-TIKRpPjKb6YMhDe>3eGMqgHpcm#)_$i=_U85= zd&a6hj*H_qJ1yA`LT6QwREcRMqQg~PDIQw)j*jtiGa*NdF~I?95Aw7tapHV9Kx4wl z0S!|**3S&&VPs;v-_tOG`1uW@iFbFB9_+ufn8R260GsNc1KSoahU|EY;FpRw3xW*6 z;te_<;b2V{L^D&iJuAsO+Gi<{hZ?fUvxX2Rtj2VdcHp~bc5NT}Af|b^q)J3W`Gub@ z$>WdeE`ZhH?C+|*Y}|@ObBDq_<;4x(JL?Z)`--Fe`lhjkV;q|SaG|Ggt&05zx@hCQ zhR|S>miik%33<&TgcH=TEJmZ7#U0;jjeotf-%;w6e2%-J_Cbw~oZ$|2IWt^q;E$66 zi9;n0n%DeKQ#nYh+ogZ9zfTf!7A34G=^ar;EFI{)9G?RB$W`ySK}npU7J1Vx$`}oJ z5il8kL#5Hqw=B*yD&)|U1G!)%6IQVne2e&+489*(0k0vC+cyls$KgLuHO#U!Ub-UR z{_TEJ4$2Rb)U|9nLd1D*`z8K?j!hOD&*5(_4AL@8=DYY=H|+Wa5o4?bt0qmSgfVvb z&d6E6 z^i9@XGq93)HJ6|X3&@(jTL3;ECzb1@35X-iW`AphGJUY3p+rT^0F@?mw&N_;>$IXQV z_J-_D*=*Q^c*pn;xQ+I69BXl3C-}*UAFCRpG{K>JJQKdgJ@4tWBqlV(izFldvPNXl(rMJ@e^4MGsA49T&o@|ApSj z??&cnktIVM-X`SmQsZ%Omy({VjQbaNjf;4AgmjS$?(tQl2Z*KV#fVYWlVw@~yQB6tR*5H9z6~C(>eG%hQ(D+qOby>;l^ELXPJ+X z?|(~2yq}}4PK?OzmRIT5aKB=Va^3Q+mA$2ze6Uh1CldiHBynW3d?NgYP1{cYP zZR@3ng(A_jZ&9DG`Ewci_PU02{}<G&;>iBGNp^v(D^Y%Xd!aIVLLWXa|A3bTU zl=n9I(|EL6^h=Wc=a;xg%m&^egKb82%=hhsk zn?H@mTyOTp8kH7V8rMux%(ITbcObe1mj0YOUQ`Ewq$wQ0lrT4#M9W@19bIrX`cM>T zu)G9_((dz;1(8R2s4D#fL0gG;%+5<-_BC#Ao_l5pogCMn0Dgy!V~kG&HV*fy=Vv)v z0BW2@IT6b-75lZhLah9#RVACDh-@pcc}|90i4B;-6Rz;c}vfP)#~CszDexDoyM> zU?T_#K&nSHVGTdFM%TUud|!k){YJHki-WknzUvvVP{EVv>e=0RoY8qzyT4}Y*Po;A zi?QrqNN67&OgAj!_BeutO5O%*WaEz{g(+_d8Q=IbQKF3BuDgJrYJAZ5*Ryl`K=<*7 z7ZatK6e@(F=3}<S=bPj^!ix%8N2+u4;F~!vGoP%D|T1qSd2Ae6KF<;8tDGA3~O-3q{4VqraUCZW$R;{`niYan)Vy_=kWMhvBHDD6!?%48Y+s{RrywGiG@ti zIe^_*v;7ou@Me8)B;aB2p_`VuWmImyv1}El`6ks}N}li>H-_8NPOerW_6Gfn02JC> z`|ZH-u{+x`{l@nqVIJXYLRB*QFGbw-j65xhquIg#sb}FS&bUl zUfjH}oYlWKv3d&ZaO+cXa=%6Qf0q#53QO1!QR7hWbEz67)vyzg(T7wJb_Ay^CekaO zrxIt`f90#ESsg>*Ch~&zzQ20Pb?^j1VMCJDFGi9W=@U2!oqd0^l%waV{7|W*IMp)kmBiXVvG}SFraQ~C2e9E#Q^ib4%dQZ~bpngdsd+T>`>9~v z8C+lE{kEFVHG4L=B0;5ZHV&SinfLn!JXouqd@x?(@bqtZ)JW?7R$cqKe5tSF`@C|9 zfzC=l)!;=9MwziiE@<_V6o~%B8l5^b# zk-Mlfj4ntKSlC!#4E6eSf}R2G8BdZ}Blr?FLR55wj-*3#=RL}&C%VzyN*e_~7-UYd znEB%khZ2(}9|NZmE#B^;f-|HO*x;c=1gYWXP1D>=RIQod4pKM|Br=kq%FO_=3hpm3 z&W3e9fUKZLQf##X@b=%z*rDXdWvuCo#T1*lYevWsV_-;Ybwbfs5eEhRr?Z4Y&l%~( zpMD+pQvU4T>#+SezcYyL7O_(>L}Z^wy-~9TVmCt8fcWL*r-zq;IACAp1XDSvzJ6y- z*T0Bs96Fo8SYz?FPGq$eg%wZpmQ=@9K1Sh%6UinY6Rdtzy^fdx4h<1z*PR6QN$Cym z^`fUEguQv~v8<-4b1zd~_4W!w2$Vm{UL}hC@WNV3ZmE3Kd+55?x9fkz8kb*`I^FV& zeUs(+M^B32h1n76`* z)w+Vx{~WmVfC#W|L(dlHkgNWfI*7t$2@GJFsbWw6&Zmfk*U~d7OZCaK_7&59_gg=f zQ{}m!Qy=p6BoJE=NaSSHl>dEK|01`FnwfrHbPGcVTaxRidl(}}`KoP-dJI21@OwjM znNKT#M%J8=ub+I}vS0rM8!~GM_aC`X!2mnf6g~Qv0(@>+DPJr2E8@g~n>QUr$-KLW zfeKH+@89(C>!^tVw>@$$)c*ValF49g^OJ&P+9=yHJ{>CH!I=x&T${ZZq%u1JB-*7p zL?`Cl0U9)B1aVl- z)3P3?2V_t$+{rD%ocaFXZ^}dbZ(?KnXw}T0Yk*EqpYaQApR?*E@sT9#d0H(sCYGyq z8d;9WvhqE|qcY+MI=p9ueZ6T2{avS7C02bMFSm+z*73pqjFuzEL4Pb86~;JrLhoOa!=ua|4sYo` zx{seyK6(!l_*wGXOipWEx!7(wD0Fsw|1_{_Oo1NR+oyKKzfgxS8ey%o_{Wmn^sh-( zzRUuxa3uO!sQ?>3Dq#Qo?iIb8b?1~8xB5|<+kplvOHhd1On_&k-cmQ$r5}v{?$MO% z1#|d7bKD`m^F2K==}5@ky+Uq{{ZGVJjd1$xshK6cl@?=*fwwxy!%9o)KbOs&oOoX( z_;NLokS-vW{sU^~XeOgg(oF{Q^z=Zx<#;}z%~R}F#ynA(D(k20+vSVb@I--Yo$t>E zu!ywMXL+7we^eo-lL)S_i8b`S^l7LZ82?K7 zlGrOssU}8{P-4S+_=zKZ`n)pCTtaOV$vcdkLz#nuuAF=ZBp4WqGQ)G$9F+C)a-|%dEwh2|$xsng@Tv`49 zaW{@fUyD#q^N^ephvd{@VH9&dsp`j~(@1?xD!~oyza-M~Df@v>Ju?>%K~y?&RgLvW<&@p(U|0>);NlAM}t&)3c0EI=!z zj!=v_bYx%D{YjfbQ*=r_J*<+!GVo{d5Ql|j&j1%!(Xl{p;N_HLq`-pg?A(8!{e(?j z+39{WHbiT}xMYFIMzn#|H7YqzTqN0M4A2tNvD%5)iYnRTl{K=0qd-fhl)$thE_J9{ zAhs#t6Pyb(%M5`gFKm0vIoMJ85_~AU{5?w)uZ|?4n@p^9W#5rA5N58|Uqn7h* z_;J83;J7|NP2@DC7uR^_KWjg)bqemua2pGA-w91K{l6~k#%MaL3r|(-2{BbJQTdl2 z@QMjv@WT1%%N**)X!v{+Gf-w`e_E36kLg5Yjh>KEl$;PiPB~~!B$xzsJ%41L@X<;d z$T%0^N4Q}SSTXKO7^oa@{6CyJJV+al{4F2ZnvK(gC z&6dG45#TEaM!2y#Nwv4N;I!@2;Y7$xKw9w=^D|GJATZZt+W!jNPA*+D)54q<0PK*X zB6$6r_I*v& zM8@>5U2f%qTbc9m4HQ=~1VR0el76WS-5Q40@zo>FKok8IQS^6J6e3Vkoqq63l- zuiSWiLk+IX32y@-aSgjn2L(e2r-Kuwz!zHHUznDE3%&Y`3qQuC9&Sg+t&ez+=T z%NkAKUnb-$)gNVQ|^v+h(i?(A81+4PqlF}WgVmL(m;A+#Fq z=uNEdJxODrbdvpqv}@w zK6?J6V%8=QwI0uNt28)Vsdz4E{`UjOEsdosBgE4Mu-HDZ_dgrv1aePHNd$Ouh|;tQ zP!yR$R8DW?7<^Mxm*%k{AFjKTG8N3dR9rd?aOfCLtDx%YdcUW7txvYKcKWcDvhjhG zqk`^B$k8|*JgMdU-_?pQWlmDJv(ji7eIQTI(;HOyYMc1py<+zHk5zDcf-=DS$!I!T zwP(XiG)PKS{q6m!NL@H{85^oapyE3~`LPVQm`J@{8>EpWdj>FyUyf~lF#9aPZ_Lw{ zZ5r%gfo@=${&TM*h`|^|p~0uvK%qgTlf)8-L(YN(>c<>L>>xdaTfdJ4;g_eE8d`GT zIRzu63f&)H5^s}kUqP(wo@t6x+91~ja8l*w|Cz%($_if4reh;KV@GUew}0s@fpZ;R zWKbD+d8QZ<`s?pmIu$MkaXD((AhbhfbP=4afy9Bgx7|2x&7qwdv}({^%lktwX4gcf z#{b?mHB0DJC@0%e2i3dM@?bGTM<^Y^ec|^VasAE%t z)z1HP1T>noG}^f^zr~V04gX@^mS91AojFKl;e_yuv>VyU{A*ayc5ESoZzZ&vf!lcjE zHzp@&{>9~D-`!OJ>eCAZ~#&O(Py(KMuw01+|JE}ibm zz*GQ6g&WDl@Oq0A(8Y37O$_1vV4pq<;_45jXXw{E;M1t-JH&X*wG}<*(45pgrq37E!qXc`(cuy`B$?F?2U|AftZH}1RcWPFqQ&_J*z*duHG`t&M&*8sSzWM4`b@=ZnrHu= zf|J*dE#`7uzcUPwZ>suPs=*Q{HBs?-sA!{tI$J55!r-e|G~$QNh-TeWNjk$NLc~eT zw943J|3|xEqHqo2CJjcL;NnY>;5Px>Nicj-NaBxi!=XcH=5x{LHKgMy=hCxEy`A_7 zWW-=pt_YhxFUXL<_r5+jIUiOV!eo{+0!5TC2Oz3$;8O)r+&w=A@O!}hPmj_Mp` zVgf+*cO9zvs5gfmNp$tkW%(kaKp^`483ZCI{G4X`rX}`NOuejwXfdTyt?S=wE1FS3 zhIHPINHUE%A6>R{G*5uF*J20bUDB{Y5c7L`!eyVWS7ECzLARtqc>+YrVJTzKS<2u4 z`Y-@Dt^lvVfK=z6N3+LsM4YNHbTgkUV*=q8)c1c4!tY)d`g9d};gPDsJ-LqZhM+d) z=3BPUh3|>{_xZz@aPw0LD&n~!qU}x|&-fycK-9I9NiLKOK6u5BUn*^F7it|Oum}I% zMqxxHkbTVJRP}F|IuVAcNcSvhR4#j;PS=avPnxubH8%qP zhawC&Ztb*D;pYcYnx3qi1VW9OK&V~wFJ5B|$*CQw$|gQ_f#FGBmx}j=%&8;3!@i7J zG_L_QD4cUMSdpG1xqGiD8&%Ma4IQrF0f+%Fg!2|DUmw2h^nbmO@I#BK?+}G9i!9E2 z^jn2!V;4go;?-w^U%4ezwh($L;HS7=2tm)2IwGDM%!r@gh`X;by=l34<*c@i4Eog&K7|M2sPjU@BvzT7|6({L>NFkepD_aRy) z^TLCwmYlL7U8s1JbJ+Nt{;+V*IW#Kw-+%>7fj%fc6DS!Ja!u$Wbk2UW@%oZk`BbvX zoOS#-`ZNE3$4wA+lcVvYAFSn(ol=V+o+u<>z8q@8C|&wDN}&veIjlwH5&H9?#{Ykm zmYOm=t)suTBafnR>UU%x{{8Byb_@qV5*i5 zv}23C5@&b|j{QL6(8|sCKm7mmUkrAmYcv^CjGw&bn0j!9SLy%$3l{q-h0lnebXOL8 z-RR!u7fgzw_Hl9VxNmgO2nG|YrX=T}4X-fEYM9ZoLQ%~Bot@L}{_|V!E78PxPb(9X zig!cUoS>TnA9~b{%yR!91`R@+P%*mb0HEL_q}vQGN3}dkT$}r=QBCx=Kp?XnyTc4L z0&pmqhs3(3-ludPUBu*{CzDf7e~T5g6sSk6Nz>YDB@!I?(EkP}Tg<33f;+pUmiT{D zLQ{zB(T4Ag=5X5F8W!Y4q*@B&-)AIc;HwBq8F(XkDX1V4^)RB=PDf}8U0Dw5N&QTs zc#jtq6h7XK3W)Q4-BU<~Ed95~hy{^{?k;5q71KYO`|zg1r<0j5hay~HgbvBwl8llA zu%`#exIPzhj3~?hQ`wWpL*1?aMN(9HOUe=@Yoo}L-LxS~BZSx9Vo72!cAC-aEoF_d z#?TwGQ+C;=WE%`6WEuMsvdzR8%gpbL-g`gye(t@0{N@j4zUO?;@|PD3>Au^Sq&FUVbtTgwg=>f8Cv3CxswuooBF9 zp|K!mp8e(1f943?bk+iyJU8{D5aNHz^KtkgCD{ot5~Jv%6K~a=KxW1#7r>^y52T?x zrse!k{)xamKXTWjH;$Yv@XOnv^)|T5!V$#18gq&{m`#K+vB%?b>`$prS7+sK9b3~5 zZUol4m4)R^!Sv47LN@;^K~yPry_h#*El#NVK&88~&!K%0KLe`HF(q)jK7!*khlKna z${v?h4V6!%*TI*t;_RdzmEsYQx=MD2AC>9y$uwx6)M;j&MDZ{v%ekv|l|PRkJGRX&|GiXXWK7~5P#f2av> zdxYhy3);Fz-c%U_91?z!AAWcu+Zy9!>2Z9+(j9*A)Ocp4{W}m(9U`ZxJvF6Vjmlf~ zAgWr&$>FYbB=SA+E?~u!q}N9BAfzVB#=u$aeA*;YH6c8X?yigEiOu9=Zr`h{cn+ViGa0dAdK>uhh8XSfKI4J2 zYE^+JXY}opEC9~9Q-I@xyQHim+2T;EZaMr)Pd%CkZhrttGEX>s2N#n)%m2B;3Xvg@ zdI-p#{OS7^mam!D8SOv*SvZ=F$5(&tlQQfah?pHuMxG5N^9dX8pwy%;2|V$Ra)`TN zBPy!esDROt@r*5(rAUH<78_1s$F^>pXB^SBdz-lY>W|=-R74auSgg-AD!C z&+R2m_{L6EGrfhkLfZVPn0pFx(29>SCu;_9=?3;{km7|R+oWQO3su_TY%(+k7Le%# zIfFUwgag{Ab(4(Z%+6;_SO)p1^{Y`Y**InZUxLHwol1ph;M@+5>D2Wlt&c&6eM3>b zgRQsEf!GdkM%SaoO1xu#+|xy>5Re*RqsnRI`NgCGk)}bYteI43y4jck6-tK3P6K!P z$me+n4yi1D@{Um}V=5HqZ~O&Pu=H61d}Mld0sN@V0ZB_L0(?`K6{PQ^f{?S+wMQtO z6{(pLzG_?|PvaR}PKkUh<(x2?AUinv@z9Hb|0@H|PY>QR?M9 z{o|!<5c!e~SOq`7TZ*Bz(kEL;>|ocB3Fnk5+0q!4ojuo^MloW_oy9{zY0sVHKNLyNa0g{y}!`zkqTT#GntJUSpRoEBz;i+Sm`MX%oLy4nYyw#319Ps`H zXRAWswv#99f8dK1z wQ>hfgXZzhHflEGiBz8cAMNs=-!cc$*(fE7&c@ye{j|)x4*Y6Gk24M-Ydy2rPPUpZq7e~ zWr-jG*Xaft8t;{Mcb?_)sUdlfx~Y9fuMDgED@%UDWyOieqS4#;k5IrM0iSc{yK1p1 z6D!eHY1q5nH4rNo@qK-U8JEW^3%@g3zNe~eE|RdG9M!=S;$CN6RDTKr)T*aUyuNLsuXZqTpDWO7G z`jr5dVKe?5cG2W%;5|oQkcr;dSpc&ARA5t$zKhmPC2&0A%W)JuyE`x}7iC_HfKsbQlG>d&?w4W^<_HwKB1dhPw0o*ImwLqZZ? zxW>%L{lrW@;2EH7)E zy5Skct-U?Z{U{(rEGs|2b2uSdd*T{(aIxzGt?Uj2@bCuF4htj!5Ng}QwLQiU7|U{5JeO}va<;o4p#aU^ce&Z1h3nzVzajwio+{7c@5_3B z=^&F*eq;RH657%IbH76K@M{al$|;9u3m#i+pre}0ZoF62{ovoY#;6+NJ7Qv&I$LKZ zFYY^VCzZ0b%&}c*CrANAT>JLK8AEWlVIdDuQ?pc7LlC#p%>)2vS0o&LG}%eFVwFB4fsKHmmW33NT|no4{=k~{9Jpq3<8!TAo!y5sBInJDwPrR5zeUB!JK$q9y`bg{Aifm z1MaONe<82?5oFM$X{Ax>bH~#>S#TlyM%okQ(T!rWdwkQ|n^X-t1-O@i{y$1KT875z zzux#`%Ka#?p*YuhQ0y(lm-0+yAP(SS4E&Y1H@8@HTJDjx{xI3yTI<#?H2m@EsdpF} zLo7y*PI4ogf#1FVo&3+>ilE`+nxC(Z3x3kQ>{~U(jciFxL$rSEh~A^XFX5ZwGA*dA zZ@M)q+J3GfP-CirF(0?&-o|LCQ$xlsyzgP#8A;K1{kGptq^7XxoUcyk5092VTcVPa z8fNcxDt$MUvmIP?r(QP;cYP-obIt>M{jkWTAE!7azt&Ir6f;^2t~?geI;`*DK$?9n z37w4#J8t1Gx9s1wyp0&(U*4gbj7gSfKLU5EwHfnhg}o=6*Np7buPdP0Qw@$mj_zvZl4T+zUFpAL~*U64A zkF2YujN@wQ1Y^SM4sQB(xz~_G*c~yD@j9&JL?}|%cn!5fL@PFj{8-aYPI1Y0SkZVa zl9tmI%?bIPcC7JldT6I1>#AjB7=?9lkUcR??H8Ic7ak_gR+`D55S3D7QPkw+x#rYaK?QOh3?#-fX6uqVBYquIo%-|=p+A+?YoFMpK=KL$dxp*&&yZ9v&U zd>8#m&Vs5`I1dWcIxp;cAy`8q*XL+$=i!Um#EbQaAKoN09mkGG79!YQLso$q; zQTu`|qLMYjj=NteU|=Cq4nEq}gyK?Z_=>3M(fiCVtkc4!pyC_kl${RiHzQ*!;ayhC zwq4og!f*P89gBuEH&i^xJX$ekH66EaI_!)io@S_`P`Fwj52@_gLFX>t=A$@fk5{W^* zI6lf5WaVIyNvt~H<9$yF$(V6W;8nBuF3OniYQWM=7Bl(9GE_hI9M6=-mSF4X2sDG% zSiAL^6ohus$jH;nw~3OF%5yO+6VbACi1Epek6$BgZ!0NL2HW*jdR?ajvlESdVj}{2 z>N~Jmtr?TN`KrE4t}{69H%Y|A@)vQZe#w>sI`@@o_t<`pFHajhjUMbISI^h2{h6=C6rti!LXl_i|3KcEB z>2Z!0-sB0BP5bN-T|ECDk#9Qlb*}nnsHx_AFByFWEs{3RpvRTOFR6xm4@@$^-4kcxM znLSNAU)n@;ZtZC`3IkhyMAiZ$aO)Fti`-)Is>uz%TkDkIWM-~wlc4K+KIAgaP;*Cw zvFMaY38x}w$2V>B0)|i9_A_Sh@d`D)zHV8#>dJ6Kz7X)eNM6$MMa@yEC8c$VWgrY& z1FfTUAbo_M^q?}9LceKLDc0xJYP6^3eWHvI)Z zrWLb@LkH{_@y@9E&u!o3J+3yX4AMrF!oqk^i#)p8fgwRFH8nItI9&m=)iXLvv2xLk z^~pEL-G6VAX8>7!fj&^|y7Wdb#)J!38{{E{L(pA3Wi-FH#`)F4S_;EM1zCsENFTK{Y=G;5i*5sdjJv*heWLhM zbe`&hRoz!_oLhFhlC3R))`OConTZw2)iDj5tgjrel9Cg`klchuMmyA&Nd(MxTUITj z&2y>nVYH#PvzkXp?h%mkPA5aM*0D`}-?YocL$WRAyL^hnV7@{$zV0}UJuZ$jN2bb*h=wkKO+^lKaUPb+7|(?;ynE!MqW>wxAFU-xf)w*N4N9%^1SZ+7ZFd@C(i<4*=AME6 zFjE@?sE=ded(0d(9Xk$KeD9ft<}}ivwHM(D{;3> zjTQaLF#tj0w8GqAb3U=_))h)r@=)|L@QvH(sa;!&w5}^pSR`F0lw8j@%`|_iM$1eqHPob7wWshMTxk1-8r<6w1&A@JC`2!~q+@AB7Uoh@z1E~HRJ80MTTs&N zI{h<9t`eE+eg7`;tFA^K>Onou%_#ff4KsXrrfvvmB2!-TV=@0N3oBAvBZn2O#kXi0 ziS|^1`v=y}Hb}<$)FgRrr>~nf3Ll2tzxYqHC$VouHqYk~-ETP+!#e;Z+hIckLjqGD z=c-d1+%GOZdE!yI711Sy?2uydZpKDeS7(xlw<{C%6PIVx(I|NggOX31=BPw1gm)fz z+IzY2owoXUb@Nadi+09Ypk6$DNG$<~?qf9DVJs2ulxR%!Zf>)&$u7$0xluJbUt#Rk zTntwesPSLUP@`p!4ug=NNhjLa7p90x5p}M#np{;{TzFDEbK(->{ocMDmX25Ni%diT z_b@i~);7fja#wg#N3@sDBOUMMr!$D5#g2Y1Z;M^(=EO@2ZksZ)62*SUUt)CSdy<~2R`*1t1 zjxI^<_o29ZOQZ+{CNJ<*Z+tPf)YsRoN#W_W7c0@UIL1=Ax{98Qpl(uqx2gjc(P;8| z?{=e1(KJ)nAguKQXd6q+Ral8L)Q?Z<1*-x?*3JM7yrf@vW_;dl?~ajnh|&4fwDyT) zTBe#3x+n_qJJfw%VzL-lRx@BpB4z^PC=RAiDl?==e^35ku{ z^FXz+-~k%2!>xF}$h;sAj2czw$J7V`p;=Ep1?Y(u4i8ir-NACH)P2*QK;zk(x;qyu1FLtM9L9FW=RP1R<^G&{Wul`qQF_=L?g&tMsw z-S6(=JZlHP%|*Zj=2eFTYG`A=yTWjKnZByW+$2~xl*V)x+UA{gE+^=gUchpvHH18O zHHv_FKFtWx#<>UtRyUMj-SS(Lv)p*Q()2zrMj3M6zY(=qATbo^I8GaQ=|x@kYMDeT z6B@Uy{HcvYWTe>2#*q3n(gW`_5 zqQR%ucqbkpaCV|6ioWBO?BMI#C!+y+WVhI8I4qknhre zMxrKB@7v|t?t9|>6-R_*Uy|SJs92nKP1IGXKDaNU(sgl)j?WSWSf)n13NV?Z)HSUG4^lza z`iNsTn+Lp(AIHAN+Q%K>z&^#98b_vBA{@xpj>aB6h_JqmGY-a!_KP3P&^tpl)d4Q& zgwgL)0Y4+tI@hG(!$ji9DF>rB-rYaCzTNZ51){|9D$WB{qRMfMMXMP#uVkx%#q7)$ zPrg{Gx{alOLKyo~Ahub~WbK2LP|W{}_ZBEwd2b32E4UzvbF#*Mrp06E!s z2UlZPFij{Ar47_5k%zhxP>Y+En~g?cx=xG|L9j~^mPfEdknGj4%+?L<+M-xh)4h#n zdvl1mEi1lWZy;c2NPr)%nImQ+`w_D>$kfi1;#8tQaT>8HJi9rbMGJ-<+*(y4WO`V{ z>$D_;bM!;vl56I+UGxigqHk<)6T-t+jnI=adO$HHwfD`q6^+_-)o~0}`?#DlM;1+k zjf8(yMM~&GjRm?2yH<$SZaj-aBqQ?U%`6akxrIZrHV(;Oy)P8a7h^Bu3XtouY67|1 zrso0OY^4vkKPjcq5=ZM^EZ6y;hi@-Eu~x2mfs#2VP9ce6@2Sh{8BdR;nD+V!3Pm)W z&1JNDZqcXEfSrZvZMU~U8tQvF>V8%Ls&EynTy~uyMD`XGEX_2NBGs*j+Sb$rsw+!y zg(MGb=aM}v_46 z9B1yLYJhO>iW;iObG`E-iY427Vt??0W@1WZ8}^urgW z&v~JiI;@G(omoS!(GntsBF=`Y6emVPF40fUSd3462Q7EPK_RE4U%=j_GM&T}F&qQK zOVc0b5oTt-%nd8lI?vf0VsK@IGOssk}F zmy|#Y+W}&;54@ebg5rKphS?peCh-m?uEf-_$TTzlOBh_@B~yrA`!<@A8WG5zd0t#% zp8?%dSudYNn8xA4?O~u4gpgLi(rC>x0nIs`|j*fF)B~{-#KU(|N z@~fy+BLN@pUvP4&Nk?PiY>`Pg(q-nTMi!lbImKmnRBFBnN+>6P*n&VH-_NJH#@YAd zIfnScJQ;$kB2829+nXPxRZn0-xkqza^2uvC{L#5I#ChA_JF4X={yWoIsTvyT%hu}g z6sK7VnbstI&bzcqRw#rk949T^;ZQ$>XwJB&z9VeP7o|PN{gf|i{>S3a(o(h7L2a3u zy31yLKBez^+dFFnn1ERuT3|ASxiK>ty`YE5j_MvToh%A^zn$neYzp z=6l6MZYOyd(J-`lFW{@DrrAm-fR)jq65io1O8}ekI=bvaO5MZ710`S^Qdf8RX(Qm4 zi$uTea+4_P#=^W|NDg2*h=LtTJNM}DGW9^~U#5heVySu2rVX#hJA67Zs#-QbsH*}D zV^M5zz*qcs_iU`r<4+k!zly`cu?`&~(G{|IUGFM6i2>m&Yah}VbR95?G;1R`zgE+f zOL!yO^r`(h!U7>{Qw&+!d`ru>dm4&|gkA1$f0ks@FLp6sFQBE95No7ptD!DwQnc{Z zbSJ0t8{NZcYpsKW<5 z$4Yxf*Y@~q+7Kr9@u5V0ygBSp=Wv7ia}L`G@<0QSbb^j#Zg=2u2|lk__Avi-L#)u7 zg|T6v1VOgI#|L~Af=!^L^Eg}ZBkE6pdJuFU`n!Pn0|IA2V8el$bWev9S+3(1n9cdQ z{iL!hgWQ++j<*Kw3-Y=S!EaIyYZ zSRwwavY=OmWGJ}#a0Dv^-4JJ%2Jb!0{CA0MAM@Y8j2;y6jopH!#WSDZ-mBaj<|M}a z`u7X9`@Fv{q6+pwW37^dptU#I8jD=PGlvpGgM+>OfHavEPJB zb=mR#7v8Wy2tlnhbz!sZRRblDy_`p6W_$c8VEBH0>$nPSk1Lhn&c^ta`@?ematvncq zz{v*icgUCSYRZVS@L5 z(Rw`d8?)AbTd7?D;|)H)I{^h}p8-&nQsrfXR=oa3j}|2;hmv~yeVD>Kuk~tpgwCT? zdB-=x$gyXN%NqNE1!PhH3J$zC_K9+Z0}{lom&uH|Xix)RI~KLSFITq|LXNd5QXYYd zX-)-@ED3-w*kUDuCAgOhj39_EoZzyQ4C^`?QqndMxM*l;7vn|1SG4Yxutr2Op8VT6zzR;LSB=uh7Bnv~~8N z!ksf$&aIPAIJGdB=iuKf38wwFcgyeH$|0bO_Cz5e{HjOM|G@G8 z32M->LNJ)to%uEnsH5mEnI%Zz??q=$=#}%lfp6!>fc;RZ;W>fb@#u8y5rl%B|0k{e zHxj|4Zcbf4q*^$+&o2u9n@0Nhv%fjaU{5`yEH&TyoaKJW8OsE!V|&a^$B%89tWerf zDp-EJ$Nwblm58#4t2&Z^*n*44nz#T)x>Nr=@yy~BGzRlq1#?h#2Frv0tpvdd^@xCZ zMm=kTLk1>+gU7*~pPX}q{(YU~uW1}J)Ccu|w(oUo+<8Cbcc^v`0J5Mj7!8}&b}V8>{=D*MvdK2H^la1KZ#mzHA@h zS6NJUAd?CO&zbPEK<))!-)XZ+#DHf|@V%=WKPSqV$D+`R_qqft=iY{gjNkk(n21Fy z^-R&I6FIxp_A)sk{+)x^%7SF<-g*rt-P9`2)43%b$M+2SAhdj9I?R{7Va-k)?xYFI_kW z-8jX3W|+Wv>F7RY@xKY6|3(zM>$stJh>ca57A9CbqP9nfSq*RQDY36x($fyKz$6bS z>Chb+sI!DYl%Tqu|C=G~3JHEZ0e%)z4#;DoR}=tWhC~2Bd1X&l$T0zkNhnxC0=n%e zB?{fXcx?6jUc3Srn6l?tKTtajl%DYo>eGzwitiTn{&X8!_1yTlbEhd86zoOyvp@BbMD0eS*vW(;bHq0ZvFixi!9fH1NDlA`~a0aSRv(@I7P6y(M;g|Z-x%a0GAnK z{}OrspT{T>+tXEHxfOC1N7Yp>+zz+BozLGTju^B-srp8Z#j z=4h)y8(Y{VyfJoVx5w9Zi5-Hv@{-osJMfCR%+`Ycx1R7{mdX9@F%@)n7b_$Sgd+Id z4+eZO*vZ5YUD?dB{nzHM)+F&1zzCE9L#sTI00&~_`}mczC=fgeY68$+ z0@Lii^>T?d_3+lTwe2^S;CoD~1rz9CTz?)ZNYG?U&7*LU#jY#u5g@$O ze}cIsE*=Bgo>O^lI`A)3g7Ar{nemKAe?R)WonH(0AAHO%1HFy}eXGxiuJ@&%WQ8{P zZ2_Mh^DphVctb)Q%9+gFqhRyf=VK85p$eh;$Mapp3NG#kxT-GGR||c;40NiO8L91g zOyK;&EBuA53NF7iX3y>h12ddJ#R^8A@&?N>CVChOV#|er5(yx*vQcrNreI_%9n88i waRFDLs8A+u@lD%;?7Qsj&(2O)9G%<@ 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 NFf+0;e6Q~j|3B^zMtcAN literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-29x29@1x.png b/apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-29x29@1x.png new file mode 100644 index 0000000000000000000000000000000000000000..6a61a35b3f35503b15804b7ef7cc67e9c36ebcdf GIT binary patch literal 1434 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 O0%)j0RVtM&L;nM?rDXR2 literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-40x40@1x.png b/apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-40x40@1x.png new file mode 100644 index 0000000000000000000000000000000000000000..2d2a3d6b72a2c0bb7cd18b1c3064166f07df1b82 GIT binary patch literal 2248 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 Q`J)1$t7WKJt!{_@555(qtN;K2 literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-40x40@3x.png b/apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-40x40@3x.png new file mode 100644 index 0000000000000000000000000000000000000000..fc8cdae3930218ddc00a8c60d3b0a7bc933a71dc GIT binary patch literal 6820 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 literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-50x50@2x.png b/apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-50x50@2x.png new file mode 100644 index 0000000000000000000000000000000000000000..f9958e015e8c04f864baf4fcb3dbbd33044600af GIT binary patch literal 5726 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 NjP=d+nsja?{R>F5*arXr literal 0 HcmV?d00001 diff --git a/apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-57x57@2x.png b/apps/mobile/apps/staff/ios/Runner/Assets.xcassets/AppIcon-dev.appiconset/Icon-App-57x57@2x.png new file mode 100644 index 0000000000000000000000000000000000000000..cb3ac623152dd51420445dcfb603e564687f07b0 GIT binary patch literal 6531 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