create-mantiq 0.7.0 → 0.7.2

package/skeleton/config/cors.ts

@@ -0,0 +1,77 @@
+import { env } from '@mantiq/core'
+
+export default {
+
+  /*
+  |--------------------------------------------------------------------------
+  | Allowed Origins
+  |--------------------------------------------------------------------------
+  |
+  | The origin(s) that are allowed to make cross-origin requests. Defaults
+  | to the APP_URL for same-origin SPA requests. Use '*' for public APIs,
+  | or an array for multiple specific origins.
+  |
+  */
+  origin: env('CORS_ORIGIN', env('APP_URL', 'http://localhost:3000')),
+
+  /*
+  |--------------------------------------------------------------------------
+  | Allowed HTTP Methods
+  |--------------------------------------------------------------------------
+  |
+  | The HTTP methods that are allowed in CORS requests.
+  |
+  */
+  methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+
+  /*
+  |--------------------------------------------------------------------------
+  | Allowed Headers
+  |--------------------------------------------------------------------------
+  |
+  | The HTTP headers that the client is allowed to send in CORS requests.
+  | X-XSRF-TOKEN is required for CSRF protection in SPA applications.
+  |
+  */
+  allowedHeaders: [
+    'Content-Type',
+    'Authorization',
+    'X-Requested-With',
+    'X-CSRF-TOKEN',
+    'X-XSRF-TOKEN',
+    'X-Mantiq',
+  ],
+
+  /*
+  |--------------------------------------------------------------------------
+  | Exposed Headers
+  |--------------------------------------------------------------------------
+  |
+  | Headers that the browser is allowed to read from the response.
+  |
+  */
+  exposedHeaders: ['X-Heartbeat'],
+
+  /*
+  |--------------------------------------------------------------------------
+  | Credentials
+  |--------------------------------------------------------------------------
+  |
+  | Whether to include credentials (cookies, Authorization header) in
+  | cross-origin requests. Must be true for session-based SPA auth.
+  | When true, origin cannot be '*'.
+  |
+  */
+  credentials: true,
+
+  /*
+  |--------------------------------------------------------------------------
+  | Preflight Max Age
+  |--------------------------------------------------------------------------
+  |
+  | How long (in seconds) the browser should cache the preflight response.
+  | Reduces the number of OPTIONS requests for repeated CORS calls.
+  |
+  */
+  maxAge: 7200,
+}

package/skeleton/config/database.ts

@@ -0,0 +1,120 @@
+import { env } from '@mantiq/core'
+
+export default {
+
+  /*
+  |--------------------------------------------------------------------------
+  | Default Database Connection
+  |--------------------------------------------------------------------------
+  |
+  | The database connection used by default for all database operations.
+  | This corresponds to one of the connections defined below. You can
+  | switch connections at runtime with db().connection('name').
+  |
+  */
+  default: env('DB_CONNECTION', 'sqlite'),
+
+  /*
+  |--------------------------------------------------------------------------
+  | Database Connections
+  |--------------------------------------------------------------------------
+  |
+  | Here are each of the database connections set up for your application.
+  | SQLite is pre-configured and requires no external services. Add
+  | additional connections for PostgreSQL, MySQL, MSSQL, or MongoDB.
+  |
+  | Supported drivers: 'sqlite', 'postgres', 'mysql', 'mssql', 'mongodb'
+  |
+  */
+  connections: {
+    sqlite: {
+      driver: 'sqlite' as const,
+      // ':memory:' for in-memory, or a file path
+      database: env('DB_DATABASE', import.meta.dir + '/../database/database.sqlite'),
+    },
+
+    // postgres: {
+    //   driver: 'postgres' as const,
+    //   host: env('DB_HOST', '127.0.0.1'),
+    //   port: Number(env('DB_PORT', '5432')),
+    //   database: env('DB_DATABASE', 'mantiq'),
+    //   user: env('DB_USERNAME', 'postgres'),
+    //   password: env('DB_PASSWORD', ''),
+    //   ssl: env('DB_SSL', 'false') === 'true',
+    //   pool: {
+    //     min: Number(env('DB_POOL_MIN', '2')),
+    //     max: Number(env('DB_POOL_MAX', '10')),
+    //   },
+    //   // Read/write splitting — route reads to replicas
+    //   // read: {
+    //   //   host: [env('DB_READ_HOST_1', '127.0.0.1'), env('DB_READ_HOST_2', '127.0.0.1')],
+    //   // },
+    //   // write: {
+    //   //   host: env('DB_WRITE_HOST', '127.0.0.1'),
+    //   // },
+    // },
+
+    // mysql: {
+    //   driver: 'mysql' as const,
+    //   host: env('DB_HOST', '127.0.0.1'),
+    //   port: Number(env('DB_PORT', '3306')),
+    //   database: env('DB_DATABASE', 'mantiq'),
+    //   user: env('DB_USERNAME', 'root'),
+    //   password: env('DB_PASSWORD', ''),
+    //   pool: {
+    //     min: Number(env('DB_POOL_MIN', '2')),
+    //     max: Number(env('DB_POOL_MAX', '10')),
+    //   },
+    //   // Read/write splitting — route reads to replicas
+    //   // read: {
+    //   //   host: [env('DB_READ_HOST_1', '127.0.0.1'), env('DB_READ_HOST_2', '127.0.0.1')],
+    //   // },
+    //   // write: {
+    //   //   host: env('DB_WRITE_HOST', '127.0.0.1'),
+    //   // },
+    // },
+
+    // mariadb: {
+    //   driver: 'mysql' as const,  // MariaDB uses the MySQL driver
+    //   host: env('DB_HOST', '127.0.0.1'),
+    //   port: Number(env('DB_PORT', '3306')),
+    //   database: env('DB_DATABASE', 'mantiq'),
+    //   user: env('DB_USERNAME', 'root'),
+    //   password: env('DB_PASSWORD', ''),
+    //   pool: {
+    //     min: Number(env('DB_POOL_MIN', '2')),
+    //     max: Number(env('DB_POOL_MAX', '10')),
+    //   },
+    //   // read: { host: [env('DB_READ_HOST_1', '127.0.0.1')] },
+    //   // write: { host: env('DB_WRITE_HOST', '127.0.0.1') },
+    // },
+
+    // mssql: {
+    //   driver: 'mssql' as const,
+    //   host: env('DB_HOST', '127.0.0.1'),
+    //   port: Number(env('DB_PORT', '1433')),
+    //   database: env('DB_DATABASE', 'mantiq'),
+    //   user: env('DB_USERNAME', 'sa'),
+    //   password: env('DB_PASSWORD', ''),
+    //   encrypt: env('DB_ENCRYPT', 'true') === 'true',
+    //   trustServerCertificate: env('DB_TRUST_CERT', 'false') === 'true',
+    //   pool: {
+    //     min: Number(env('DB_POOL_MIN', '2')),
+    //     max: Number(env('DB_POOL_MAX', '10')),
+    //   },
+    //   // read: { host: [env('DB_READ_HOST_1', '127.0.0.1')] },
+    //   // write: { host: env('DB_WRITE_HOST', '127.0.0.1') },
+    // },
+
+    // mongodb: {
+    //   driver: 'mongodb' as const,
+    //   uri: env('MONGODB_URL', 'mongodb://127.0.0.1:27017'),
+    //   database: env('DB_DATABASE', 'mantiq'),
+    //   options: {
+    //     // Any MongoClient options: retryWrites, w, etc.
+    //   },
+    //   // Read preference for replicas
+    //   // readPreference: 'secondaryPreferred',
+    // },
+  },
+}

package/skeleton/config/filesystem.ts

@@ -0,0 +1,58 @@
+import { env } from '@mantiq/core'
+
+export default {
+
+  /*
+  |--------------------------------------------------------------------------
+  | Default Filesystem Disk
+  |--------------------------------------------------------------------------
+  |
+  | The default filesystem disk used by the storage() helper and all
+  | file operations. You may use any of the disks defined below.
+  |
+  */
+  default: env('FILESYSTEM_DISK', 'local'),
+
+  /*
+  |--------------------------------------------------------------------------
+  | Filesystem Disks
+  |--------------------------------------------------------------------------
+  |
+  | Here you may configure as many filesystem "disks" as you wish. Each
+  | disk represents a particular storage driver and location.
+  |
+  | Supported drivers: 'local', 's3', 'gcs', 'r2', 'azure', 'ftp', 'sftp'
+  |
+  */
+  disks: {
+    // Private storage — not web-accessible (uploads, temp files, exports)
+    local: {
+      driver: 'local' as const,
+      root: import.meta.dir + '/../storage/app',
+    },
+
+    // Public storage — web-accessible via /storage URL
+    // Run: bun mantiq storage:link
+    public: {
+      driver: 'local' as const,
+      root: import.meta.dir + '/../storage/app/public',
+      visibility: 'public' as const,
+    },
+
+    // s3: {
+    //   driver: 's3' as const,
+    //   bucket: env('AWS_BUCKET', ''),
+    //   region: env('AWS_REGION', 'us-east-1'),
+    //   accessKeyId: env('AWS_ACCESS_KEY_ID', ''),
+    //   secretAccessKey: env('AWS_SECRET_ACCESS_KEY', ''),
+    // },
+
+    // r2: {
+    //   driver: 'r2' as const,
+    //   accountId: env('CLOUDFLARE_ACCOUNT_ID', ''),
+    //   bucket: env('R2_BUCKET', ''),
+    //   accessKeyId: env('R2_ACCESS_KEY_ID', ''),
+    //   secretAccessKey: env('R2_SECRET_ACCESS_KEY', ''),
+    // },
+  },
+}

package/skeleton/config/hashing.ts

@@ -0,0 +1,47 @@
+import { env } from '@mantiq/core'
+
+export default {
+
+  /*
+  |--------------------------------------------------------------------------
+  | Default Hash Driver
+  |--------------------------------------------------------------------------
+  |
+  | This option controls the default hash driver used for hashing
+  | passwords and other values. Bcrypt is the recommended default.
+  |
+  | Supported: 'bcrypt', 'argon2'
+  |
+  */
+  driver: env('HASH_DRIVER', 'bcrypt'),
+
+  /*
+  |--------------------------------------------------------------------------
+  | Bcrypt Options
+  |--------------------------------------------------------------------------
+  |
+  | Here you may configure the round count used by the Bcrypt hashing
+  | algorithm. Higher rounds increase security but also increase the
+  | time required to hash a value (10-12 recommended).
+  |
+  */
+  bcrypt: {
+    rounds: Number(env('BCRYPT_ROUNDS', '10')),
+  },
+
+  /*
+  |--------------------------------------------------------------------------
+  | Argon2 Options
+  |--------------------------------------------------------------------------
+  |
+  | Here you may configure the memory cost, time cost, and parallelism
+  | used by the Argon2 hashing algorithm. These values control the
+  | difficulty of producing a valid hash.
+  |
+  */
+  argon2: {
+    memory: 65536,   // Memory cost in KiB (64 MB)
+    time: 4,         // Number of iterations
+    parallelism: 1,  // Degree of parallelism
+  },
+}

package/skeleton/config/heartbeat.ts

@@ -0,0 +1,112 @@
+export default {
+
+  /*
+  |--------------------------------------------------------------------------
+  | Heartbeat Enabled
+  |--------------------------------------------------------------------------
+  |
+  | Master switch for the APM & observability system. When disabled, no
+  | telemetry is recorded and the dashboard is inaccessible.
+  |
+  */
+  enabled: true,
+
+  /*
+  |--------------------------------------------------------------------------
+  | Telemetry Storage
+  |--------------------------------------------------------------------------
+  |
+  | Where Heartbeat stores request traces, queries, exceptions, and other
+  | telemetry data. SQLite is zero-config. Retention controls how long
+  | entries are kept before automatic pruning.
+  |
+  */
+  storage: {
+    driver: 'sqlite' as const,
+    path: 'storage/heartbeat/heartbeat.sqlite',
+    retention: 86400,    // Seconds to keep entries (86400 = 24 hours)
+    pruneInterval: 300,  // Seconds between prune runs (300 = 5 minutes)
+  },
+
+  /*
+  |--------------------------------------------------------------------------
+  | Queue Configuration
+  |--------------------------------------------------------------------------
+  |
+  | Controls how telemetry data is flushed to storage. Use 'sync' for
+  | immediate writes (simpler) or a queue connection for async (faster).
+  |
+  */
+  queue: {
+    connection: 'sync',
+    queue: 'heartbeat',
+    batchSize: 50,       // Entries to flush per batch
+    flushInterval: 1000, // Milliseconds between flushes
+  },
+
+  /*
+  |--------------------------------------------------------------------------
+  | Watchers
+  |--------------------------------------------------------------------------
+  |
+  | Each watcher monitors a specific aspect of your application. Disable
+  | individual watchers to reduce telemetry volume or ignore specific
+  | classes/routes via the ignore arrays.
+  |
+  */
+  watchers: {
+    request:   { enabled: true, slow_threshold: 1000, ignore: [] },  // ms
+    query:     { enabled: true, slow_threshold: 100, detect_n_plus_one: true },  // ms
+    exception: { enabled: true, ignore: [] },
+    cache:     { enabled: true },
+    job:       { enabled: true },
+    event:     { enabled: true, ignore: [] },
+    model:     { enabled: true },
+    log:       { enabled: true, level: 'debug' },
+    schedule:  { enabled: true },
+  },
+
+  /*
+  |--------------------------------------------------------------------------
+  | Distributed Tracing
+  |--------------------------------------------------------------------------
+  |
+  | When enabled, Heartbeat generates trace IDs and propagates them across
+  | service boundaries via HTTP headers for end-to-end request tracking.
+  |
+  */
+  tracing: {
+    enabled: true,
+    propagate: true,
+  },
+
+  /*
+  |--------------------------------------------------------------------------
+  | Sampling
+  |--------------------------------------------------------------------------
+  |
+  | In high-traffic environments, record only a fraction of requests to
+  | reduce storage and performance overhead. Errors are always recorded
+  | regardless of the sampling rate.
+  |
+  */
+  sampling: {
+    rate: 1.0,                  // 1.0 = 100%, 0.1 = 10%
+    always_sample_errors: true,
+  },
+
+  /*
+  |--------------------------------------------------------------------------
+  | Dashboard
+  |--------------------------------------------------------------------------
+  |
+  | The built-in web dashboard for viewing recorded telemetry. Protect it
+  | with middleware in production (e.g., ['auth'] to require login).
+  |
+  */
+  dashboard: {
+    enabled: true,
+    path: '/_heartbeat',
+    middleware: [],
+  },
+}

package/skeleton/config/logging.ts

@@ -0,0 +1,58 @@
+import { env } from '@mantiq/core'
+
+export default {
+
+  /*
+  |--------------------------------------------------------------------------
+  | Default Log Channel
+  |--------------------------------------------------------------------------
+  |
+  | This option defines the default log channel that gets used when writing
+  | messages to the logs. The "stack" channel sends to multiple channels
+  | simultaneously (e.g., console + daily file).
+  |
+  */
+  default: env('LOG_CHANNEL', 'stack'),
+
+  /*
+  |--------------------------------------------------------------------------
+  | Log Channels
+  |--------------------------------------------------------------------------
+  |
+  | Here you may configure the log channels for your application. Each
+  | channel represents a specific destination for log messages.
+  |
+  | Supported drivers: 'stack', 'console', 'file', 'daily'
+  | Log levels: 'emergency', 'alert', 'critical', 'error',
+  |             'warning', 'notice', 'info', 'debug'
+  |
+  */
+  channels: {
+    // Sends messages to multiple channels at once
+    stack: {
+      driver: 'stack' as const,
+      channels: ['console', 'daily'],
+    },
+
+    // Writes to stdout — ideal for development and container deployments
+    console: {
+      driver: 'console' as const,
+      level: 'debug' as const,
+    },
+
+    // Rotates log files daily — automatically cleans up old files
+    daily: {
+      driver: 'daily' as const,
+      path: 'storage/logs/mantiq.log',
+      level: 'debug' as const,
+      days: 14,  // Number of days to retain
+    },
+
+    // Single log file — no rotation
+    file: {
+      driver: 'file' as const,
+      path: 'storage/logs/mantiq.log',
+      level: 'debug' as const,
+    },
+  },
+}

package/skeleton/config/mail.ts

@@ -0,0 +1,93 @@
+import { env } from '@mantiq/core'
+
+export default {
+
+  /*
+  |--------------------------------------------------------------------------
+  | Default Mailer
+  |--------------------------------------------------------------------------
+  |
+  | This option controls the default mailer used to send emails. The "log"
+  | mailer writes email content to your log file — safe for development.
+  |
+  | Supported: 'smtp', 'resend', 'sendgrid', 'mailgun', 'postmark',
+  |            'ses', 'log', 'array'
+  |
+  */
+  default: env('MAIL_MAILER', 'log'),
+
+  /*
+  |--------------------------------------------------------------------------
+  | Global "From" Address
+  |--------------------------------------------------------------------------
+  |
+  | The default sender address used when a mailable doesn't specify its own.
+  | All emails sent by your application will use this address unless
+  | explicitly overridden.
+  |
+  */
+  from: {
+    address: env('MAIL_FROM_ADDRESS', 'hello@example.com'),
+    name: env('MAIL_FROM_NAME', 'MantiqJS'),
+  },
+
+  /*
+  |--------------------------------------------------------------------------
+  | Mailer Configurations
+  |--------------------------------------------------------------------------
+  |
+  | Here you may configure all of the mailers used by your application.
+  | Each mailer uses a specific transport driver and credentials.
+  |
+  */
+  mailers: {
+    // Standard SMTP — works with any SMTP server (Mailtrap, Gmail, etc.)
+    smtp: {
+      driver: 'smtp' as const,
+      host: env('MAIL_HOST', 'localhost'),
+      port: Number(env('MAIL_PORT', '587')),
+      username: env('MAIL_USERNAME', ''),
+      password: env('MAIL_PASSWORD', ''),
+      encryption: env('MAIL_ENCRYPTION', 'starttls') as 'tls' | 'starttls' | 'none',
+    },
+
+    // Resend — modern email API (https://resend.com)
+    resend: {
+      driver: 'resend' as const,
+      apiKey: env('RESEND_API_KEY', ''),
+    },
+
+    // SendGrid (https://sendgrid.com)
+    sendgrid: {
+      driver: 'sendgrid' as const,
+      apiKey: env('SENDGRID_API_KEY', ''),
+    },
+
+    // Mailgun (https://mailgun.com)
+    mailgun: {
+      driver: 'mailgun' as const,
+      apiKey: env('MAILGUN_API_KEY', ''),
+      domain: env('MAILGUN_DOMAIN', ''),
+    },
+
+    // Postmark (https://postmarkapp.com)
+    postmark: {
+      driver: 'postmark' as const,
+      serverToken: env('POSTMARK_TOKEN', ''),
+    },
+
+    // Amazon SES
+    ses: {
+      driver: 'ses' as const,
+      region: env('AWS_REGION', 'us-east-1'),
+      accessKeyId: env('AWS_ACCESS_KEY_ID', ''),
+      secretAccessKey: env('AWS_SECRET_ACCESS_KEY', ''),
+    },
+
+    // Writes email content to log file (development)
+    log: { driver: 'log' as const },
+
+    // Stores emails in memory (unit testing)
+    array: { driver: 'array' as const },
+  },
+}