@objectifthunes/create-sandstone 0.2.0 → 1.0.0

package/dist/commands/add-adapter.js

@@ -0,0 +1,683 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+const KNOWN_ADAPTERS = {
+    pg: {
+        displayName: 'PostgreSQL (pg)',
+        subpath: './pg',
+        factoryName: 'createPgClient',
+        appOption: 'db',
+        envVars: {
+            DATABASE_URL: 'postgres://user:password@localhost:5432/mydb',
+        },
+        peerDep: 'pg',
+        importExample: `import { createPgClient } from '@objectifthunes/sandstone-sdk/pg';`,
+        wiringExample: `  db: createPgClient({ connectionString: process.env.DATABASE_URL! }),`,
+    },
+    supabase: {
+        displayName: 'Supabase',
+        subpath: './supabase',
+        factoryName: 'createSupabaseClient',
+        appOption: 'db',
+        envVars: {
+            DATABASE_URL: 'postgres://postgres.<ref>:<password>@aws-0-<region>.pooler.supabase.com:6543/postgres',
+        },
+        peerDep: 'pg',
+        importExample: `import { createSupabaseClient } from '@objectifthunes/sandstone-sdk/supabase';`,
+        wiringExample: `  db: createSupabaseClient({ connectionString: process.env.DATABASE_URL! }),`,
+    },
+    jose: {
+        displayName: 'Jose (JWT)',
+        subpath: './jose',
+        factoryName: 'createJoseSigner',
+        appOption: 'tokens',
+        envVars: {
+            JWT_SECRET: 'your-secret-key-at-least-32-characters-long',
+        },
+        peerDep: 'jose',
+        importExample: `import { createJoseSigner } from '@objectifthunes/sandstone-sdk/jose';`,
+        wiringExample: `  tokens: createJoseSigner({ secret: process.env.JWT_SECRET! }),`,
+    },
+    pino: {
+        displayName: 'Pino (Logger)',
+        subpath: './pino',
+        factoryName: 'createPinoLogger',
+        appOption: 'logger',
+        envVars: {
+            LOG_LEVEL: 'info',
+        },
+        peerDep: 'pino',
+        importExample: `import { createPinoLogger } from '@objectifthunes/sandstone-sdk/pino';`,
+        wiringExample: `  logger: createPinoLogger({ level: process.env.LOG_LEVEL ?? 'info' }),`,
+    },
+    resend: {
+        displayName: 'Resend (Email)',
+        subpath: './resend',
+        factoryName: 'createResendTransport',
+        appOption: 'email',
+        envVars: {
+            RESEND_API_KEY: 're_xxxxxxxxxx',
+            EMAIL_FROM: 'noreply@yourdomain.com',
+        },
+        peerDep: 'resend',
+        importExample: `import { createResendTransport } from '@objectifthunes/sandstone-sdk/resend';`,
+        wiringExample: `  email: {
+    transport: createResendTransport({ apiKey: process.env.RESEND_API_KEY! }),
+    defaultFrom: process.env.EMAIL_FROM!,
+  },`,
+    },
+    nodemailer: {
+        displayName: 'Nodemailer (SMTP)',
+        subpath: './nodemailer',
+        factoryName: 'createNodemailerTransport',
+        appOption: 'email',
+        envVars: {
+            SMTP_HOST: 'smtp.example.com',
+            SMTP_PORT: '587',
+            SMTP_USER: 'your-smtp-user',
+            SMTP_PASS: 'your-smtp-password',
+            EMAIL_FROM: 'noreply@yourdomain.com',
+        },
+        peerDep: 'nodemailer',
+        importExample: `import { createNodemailerTransport } from '@objectifthunes/sandstone-sdk/nodemailer';`,
+        wiringExample: `  email: {
+    transport: createNodemailerTransport({
+      host: process.env.SMTP_HOST!,
+      port: parseInt(process.env.SMTP_PORT!, 10),
+      auth: { user: process.env.SMTP_USER!, pass: process.env.SMTP_PASS! },
+    }),
+    defaultFrom: process.env.EMAIL_FROM!,
+  },`,
+    },
+    stripe: {
+        displayName: 'Stripe (Payments)',
+        subpath: './stripe',
+        factoryName: 'createStripeProvider',
+        appOption: 'payments',
+        envVars: {
+            STRIPE_SECRET_KEY: 'sk_test_xxxxxxxxxx',
+            STRIPE_WEBHOOK_SECRET: 'whsec_xxxxxxxxxx',
+        },
+        peerDep: 'stripe',
+        importExample: `import { createStripeProvider } from '@objectifthunes/sandstone-sdk/stripe';`,
+        wiringExample: `  payments: {
+    provider: createStripeProvider({
+      secretKey: process.env.STRIPE_SECRET_KEY!,
+      webhookSecret: process.env.STRIPE_WEBHOOK_SECRET!,
+    }),
+  },`,
+    },
+    paddle: {
+        displayName: 'Paddle (Payments)',
+        subpath: './paddle',
+        factoryName: 'createPaddleProvider',
+        appOption: 'payments',
+        envVars: {
+            PADDLE_API_KEY: 'pdl_xxxxxxxxxx',
+            PADDLE_WEBHOOK_SECRET: 'pdl_ntfset_xxxxxxxxxx',
+        },
+        peerDep: null,
+        importExample: `import { createPaddleProvider } from '@objectifthunes/sandstone-sdk/paddle';`,
+        wiringExample: `  payments: {
+    provider: createPaddleProvider({
+      apiKey: process.env.PADDLE_API_KEY!,
+      webhookSecret: process.env.PADDLE_WEBHOOK_SECRET!,
+    }),
+  },`,
+    },
+    lemonsqueezy: {
+        displayName: 'Lemon Squeezy (Payments)',
+        subpath: './lemonsqueezy',
+        factoryName: 'createLemonSqueezyProvider',
+        appOption: 'payments',
+        envVars: {
+            LEMONSQUEEZY_API_KEY: 'your-api-key',
+            LEMONSQUEEZY_STORE_ID: 'your-store-id',
+            LEMONSQUEEZY_WEBHOOK_SECRET: 'your-webhook-secret',
+        },
+        peerDep: null,
+        importExample: `import { createLemonSqueezyProvider } from '@objectifthunes/sandstone-sdk/lemonsqueezy';`,
+        wiringExample: `  payments: {
+    provider: createLemonSqueezyProvider({
+      apiKey: process.env.LEMONSQUEEZY_API_KEY!,
+      storeId: process.env.LEMONSQUEEZY_STORE_ID!,
+      webhookSecret: process.env.LEMONSQUEEZY_WEBHOOK_SECRET!,
+    }),
+  },`,
+    },
+    revenuecat: {
+        displayName: 'RevenueCat (Payments)',
+        subpath: './revenuecat',
+        factoryName: 'createRevenueCatProvider',
+        appOption: 'payments',
+        envVars: {
+            REVENUECAT_API_KEY: 'your-api-key',
+            REVENUECAT_WEBHOOK_SECRET: 'your-webhook-secret',
+        },
+        peerDep: null,
+        importExample: `import { createRevenueCatProvider } from '@objectifthunes/sandstone-sdk/revenuecat';`,
+        wiringExample: `  payments: {
+    provider: createRevenueCatProvider({
+      apiKey: process.env.REVENUECAT_API_KEY!,
+      webhookSecret: process.env.REVENUECAT_WEBHOOK_SECRET!,
+    }),
+  },`,
+    },
+    s3: {
+        displayName: 'AWS S3 (Storage)',
+        subpath: './s3',
+        factoryName: 'createS3Storage',
+        appOption: 'storage',
+        envVars: {
+            S3_BUCKET: 'my-bucket',
+            S3_REGION: 'us-east-1',
+            AWS_ACCESS_KEY_ID: 'your-access-key',
+            AWS_SECRET_ACCESS_KEY: 'your-secret-key',
+        },
+        peerDep: '@aws-sdk/client-s3',
+        importExample: `import { createS3Storage } from '@objectifthunes/sandstone-sdk/s3';`,
+        wiringExample: `  storage: createS3Storage({
+    bucket: process.env.S3_BUCKET!,
+    region: process.env.S3_REGION!,
+  }),`,
+    },
+    r2: {
+        displayName: 'Cloudflare R2 (Storage)',
+        subpath: './r2',
+        factoryName: 'createR2Storage',
+        appOption: 'storage',
+        envVars: {
+            R2_BUCKET: 'my-bucket',
+            R2_ACCOUNT_ID: 'your-account-id',
+            R2_ACCESS_KEY_ID: 'your-access-key',
+            R2_SECRET_ACCESS_KEY: 'your-secret-key',
+        },
+        peerDep: '@aws-sdk/client-s3',
+        importExample: `import { createR2Storage } from '@objectifthunes/sandstone-sdk/r2';`,
+        wiringExample: `  storage: createR2Storage({
+    bucket: process.env.R2_BUCKET!,
+    accountId: process.env.R2_ACCOUNT_ID!,
+  }),`,
+    },
+    redis: {
+        displayName: 'Redis (Cache)',
+        subpath: './redis',
+        factoryName: 'createRedisCache',
+        appOption: 'cache',
+        envVars: {
+            REDIS_URL: 'redis://localhost:6379',
+        },
+        peerDep: 'ioredis',
+        importExample: `import { createRedisCache } from '@objectifthunes/sandstone-sdk/redis';`,
+        wiringExample: `  cache: createRedisCache({ url: process.env.REDIS_URL! }),`,
+    },
+    upstash: {
+        displayName: 'Upstash Redis (Cache)',
+        subpath: './upstash',
+        factoryName: 'createUpstashCache',
+        appOption: 'cache',
+        envVars: {
+            UPSTASH_REDIS_URL: 'https://xxxxxx.upstash.io',
+            UPSTASH_REDIS_TOKEN: 'your-token',
+        },
+        peerDep: '@upstash/redis',
+        importExample: `import { createUpstashCache } from '@objectifthunes/sandstone-sdk/upstash';`,
+        wiringExample: `  cache: createUpstashCache({
+    url: process.env.UPSTASH_REDIS_URL!,
+    token: process.env.UPSTASH_REDIS_TOKEN!,
+  }),`,
+    },
+    argon2: {
+        displayName: 'Argon2 (Password Hashing)',
+        subpath: './argon2',
+        factoryName: 'createArgon2Hasher',
+        appOption: 'auth (passwordHasher)',
+        envVars: {},
+        peerDep: 'argon2',
+        importExample: `import { createArgon2Hasher } from '@objectifthunes/sandstone-sdk/argon2';`,
+        wiringExample: `  auth: { passwordHasher: createArgon2Hasher() },`,
+    },
+    'oauth-google': {
+        displayName: 'Google OAuth',
+        subpath: './oauth-google',
+        factoryName: 'createGoogleOAuthProvider',
+        appOption: 'auth (oauthProviders)',
+        envVars: {
+            GOOGLE_CLIENT_ID: 'your-client-id.apps.googleusercontent.com',
+            GOOGLE_CLIENT_SECRET: 'your-client-secret',
+        },
+        peerDep: null,
+        importExample: `import { createGoogleOAuthProvider } from '@objectifthunes/sandstone-sdk/oauth-google';`,
+        wiringExample: `  auth: {
+    oauthProviders: {
+      google: createGoogleOAuthProvider({
+        clientId: process.env.GOOGLE_CLIENT_ID!,
+        clientSecret: process.env.GOOGLE_CLIENT_SECRET!,
+      }),
+    },
+  },`,
+    },
+    'oauth-github': {
+        displayName: 'GitHub OAuth',
+        subpath: './oauth-github',
+        factoryName: 'createGitHubOAuthProvider',
+        appOption: 'auth (oauthProviders)',
+        envVars: {
+            GITHUB_CLIENT_ID: 'your-client-id',
+            GITHUB_CLIENT_SECRET: 'your-client-secret',
+        },
+        peerDep: null,
+        importExample: `import { createGitHubOAuthProvider } from '@objectifthunes/sandstone-sdk/oauth-github';`,
+        wiringExample: `  auth: {
+    oauthProviders: {
+      github: createGitHubOAuthProvider({
+        clientId: process.env.GITHUB_CLIENT_ID!,
+        clientSecret: process.env.GITHUB_CLIENT_SECRET!,
+      }),
+    },
+  },`,
+    },
+    'oauth-apple': {
+        displayName: 'Apple OAuth',
+        subpath: './oauth-apple',
+        factoryName: 'createAppleOAuthProvider',
+        appOption: 'auth (oauthProviders)',
+        envVars: {
+            APPLE_CLIENT_ID: 'com.your.service-id',
+            APPLE_TEAM_ID: 'your-team-id',
+            APPLE_KEY_ID: 'your-key-id',
+            APPLE_PRIVATE_KEY: '-----BEGIN PRIVATE KEY-----\\n...\\n-----END PRIVATE KEY-----',
+        },
+        peerDep: null,
+        importExample: `import { createAppleOAuthProvider } from '@objectifthunes/sandstone-sdk/oauth-apple';`,
+        wiringExample: `  auth: {
+    oauthProviders: {
+      apple: createAppleOAuthProvider({
+        clientId: process.env.APPLE_CLIENT_ID!,
+        teamId: process.env.APPLE_TEAM_ID!,
+        keyId: process.env.APPLE_KEY_ID!,
+        privateKey: process.env.APPLE_PRIVATE_KEY!,
+      }),
+    },
+  },`,
+    },
+    'oauth-discord': {
+        displayName: 'Discord OAuth',
+        subpath: './oauth-discord',
+        factoryName: 'createDiscordOAuthProvider',
+        appOption: 'auth (oauthProviders)',
+        envVars: {
+            DISCORD_CLIENT_ID: 'your-client-id',
+            DISCORD_CLIENT_SECRET: 'your-client-secret',
+        },
+        peerDep: null,
+        importExample: `import { createDiscordOAuthProvider } from '@objectifthunes/sandstone-sdk/oauth-discord';`,
+        wiringExample: `  auth: {
+    oauthProviders: {
+      discord: createDiscordOAuthProvider({
+        clientId: process.env.DISCORD_CLIENT_ID!,
+        clientSecret: process.env.DISCORD_CLIENT_SECRET!,
+      }),
+    },
+  },`,
+    },
+    otel: {
+        displayName: 'OpenTelemetry (Tracing)',
+        subpath: './otel',
+        factoryName: 'createOtelTracer',
+        appOption: 'tracer',
+        envVars: {
+            OTEL_SERVICE_NAME: 'my-service',
+        },
+        peerDep: '@opentelemetry/api',
+        importExample: `import { createOtelTracer } from '@objectifthunes/sandstone-sdk/otel';`,
+        wiringExample: `  tracer: createOtelTracer({ serviceName: process.env.OTEL_SERVICE_NAME ?? 'my-service' }),`,
+    },
+    meilisearch: {
+        displayName: 'Meilisearch (Search)',
+        subpath: './meilisearch',
+        factoryName: 'createMeilisearchSearch',
+        appOption: 'search',
+        envVars: {
+            MEILISEARCH_HOST: 'http://localhost:7700',
+            MEILISEARCH_API_KEY: 'your-master-key',
+        },
+        peerDep: 'meilisearch',
+        importExample: `import { createMeilisearchSearch } from '@objectifthunes/sandstone-sdk/meilisearch';`,
+        wiringExample: `  search: createMeilisearchSearch({
+    host: process.env.MEILISEARCH_HOST!,
+    apiKey: process.env.MEILISEARCH_API_KEY!,
+  }),`,
+    },
+    typesense: {
+        displayName: 'Typesense (Search)',
+        subpath: './typesense',
+        factoryName: 'createTypesenseSearch',
+        appOption: 'search',
+        envVars: {
+            TYPESENSE_HOST: 'localhost',
+            TYPESENSE_PORT: '8108',
+            TYPESENSE_API_KEY: 'your-api-key',
+        },
+        peerDep: 'typesense',
+        importExample: `import { createTypesenseSearch } from '@objectifthunes/sandstone-sdk/typesense';`,
+        wiringExample: `  search: createTypesenseSearch({
+    host: process.env.TYPESENSE_HOST!,
+    port: parseInt(process.env.TYPESENSE_PORT!, 10),
+    apiKey: process.env.TYPESENSE_API_KEY!,
+  }),`,
+    },
+    bullmq: {
+        displayName: 'BullMQ (Queue)',
+        subpath: './bullmq',
+        factoryName: 'createBullMQQueue',
+        appOption: 'queue',
+        envVars: {
+            REDIS_URL: 'redis://localhost:6379',
+        },
+        peerDep: 'bullmq',
+        importExample: `import { createBullMQQueue } from '@objectifthunes/sandstone-sdk/bullmq';`,
+        wiringExample: `  queue: createBullMQQueue({ connection: { url: process.env.REDIS_URL! } }),`,
+    },
+    'pg-boss': {
+        displayName: 'pg-boss (Queue)',
+        subpath: './pg-boss',
+        factoryName: 'createPgBossQueue',
+        appOption: 'queue',
+        envVars: {
+            DATABASE_URL: 'postgres://user:password@localhost:5432/mydb',
+        },
+        peerDep: 'pg-boss',
+        importExample: `import { createPgBossQueue } from '@objectifthunes/sandstone-sdk/pg-boss';`,
+        wiringExample: `  queue: createPgBossQueue({ connectionString: process.env.DATABASE_URL! }),`,
+    },
+    'pg-flags': {
+        displayName: 'PostgreSQL Feature Flags',
+        subpath: './pg-flags',
+        factoryName: 'createPgFeatureFlags',
+        appOption: 'flags',
+        envVars: {},
+        peerDep: 'pg',
+        importExample: `import { createPgFeatureFlags } from '@objectifthunes/sandstone-sdk/pg-flags';`,
+        wiringExample: `  flags: createPgFeatureFlags({ db }),  // pass the DatabaseClient instance`,
+    },
+    'env-flags': {
+        displayName: 'Environment Variable Feature Flags',
+        subpath: './env-flags',
+        factoryName: 'createEnvFeatureFlags',
+        appOption: 'flags',
+        envVars: {},
+        peerDep: null,
+        importExample: `import { createEnvFeatureFlags } from '@objectifthunes/sandstone-sdk/env-flags';`,
+        wiringExample: `  flags: createEnvFeatureFlags({ prefix: 'FLAG_' }),`,
+    },
+    launchdarkly: {
+        displayName: 'LaunchDarkly (Feature Flags)',
+        subpath: './launchdarkly',
+        factoryName: 'createLaunchDarklyFlags',
+        appOption: 'flags',
+        envVars: {
+            LAUNCHDARKLY_SDK_KEY: 'sdk-xxxxxxxxxx',
+        },
+        peerDep: '@launchdarkly/node-server-sdk',
+        importExample: `import { createLaunchDarklyFlags } from '@objectifthunes/sandstone-sdk/launchdarkly';`,
+        wiringExample: `  flags: createLaunchDarklyFlags({ sdkKey: process.env.LAUNCHDARKLY_SDK_KEY! }),`,
+    },
+    'pg-authz': {
+        displayName: 'PostgreSQL Authorization',
+        subpath: './pg-authz',
+        factoryName: 'createPgAuthzProvider',
+        appOption: 'authz',
+        envVars: {},
+        peerDep: 'pg',
+        importExample: `import { createPgAuthzProvider } from '@objectifthunes/sandstone-sdk/pg-authz';`,
+        wiringExample: `  authz: createPgAuthzProvider({ db }),  // pass the DatabaseClient instance`,
+    },
+    casbin: {
+        displayName: 'Casbin (Authorization)',
+        subpath: './casbin',
+        factoryName: 'createCasbinAuthzProvider',
+        appOption: 'authz',
+        envVars: {},
+        peerDep: 'casbin',
+        importExample: `import { createCasbinAuthzProvider } from '@objectifthunes/sandstone-sdk/casbin';`,
+        wiringExample: `  authz: createCasbinAuthzProvider({ modelPath: './model.conf', policyPath: './policy.csv' }),`,
+    },
+    twilio: {
+        displayName: 'Twilio (SMS)',
+        subpath: './twilio',
+        factoryName: 'createTwilioSmsTransport',
+        appOption: 'sms',
+        envVars: {
+            TWILIO_ACCOUNT_SID: 'ACxxxxxxxxxx',
+            TWILIO_AUTH_TOKEN: 'your-auth-token',
+            TWILIO_FROM_NUMBER: '+15551234567',
+        },
+        peerDep: null,
+        importExample: `import { createTwilioSmsTransport } from '@objectifthunes/sandstone-sdk/twilio';`,
+        wiringExample: `  sms: createTwilioSmsTransport({
+    accountSid: process.env.TWILIO_ACCOUNT_SID!,
+    authToken: process.env.TWILIO_AUTH_TOKEN!,
+    from: process.env.TWILIO_FROM_NUMBER!,
+  }),`,
+    },
+    sns: {
+        displayName: 'AWS SNS (SMS)',
+        subpath: './sns',
+        factoryName: 'createSnsSmsTransport',
+        appOption: 'sms',
+        envVars: {
+            AWS_REGION: 'us-east-1',
+            AWS_ACCESS_KEY_ID: 'your-access-key',
+            AWS_SECRET_ACCESS_KEY: 'your-secret-key',
+        },
+        peerDep: '@aws-sdk/client-sns',
+        importExample: `import { createSnsSmsTransport } from '@objectifthunes/sandstone-sdk/sns';`,
+        wiringExample: `  sms: createSnsSmsTransport({ region: process.env.AWS_REGION! }),`,
+    },
+    fcm: {
+        displayName: 'Firebase Cloud Messaging (Push)',
+        subpath: './fcm',
+        factoryName: 'createFcmPushTransport',
+        appOption: 'push',
+        envVars: {
+            FCM_PROJECT_ID: 'your-project-id',
+            FCM_CLIENT_EMAIL: 'firebase-adminsdk@your-project.iam.gserviceaccount.com',
+            FCM_PRIVATE_KEY: '-----BEGIN PRIVATE KEY-----\\n...\\n-----END PRIVATE KEY-----',
+        },
+        peerDep: null,
+        importExample: `import { createFcmPushTransport } from '@objectifthunes/sandstone-sdk/fcm';`,
+        wiringExample: `  push: createFcmPushTransport({
+    projectId: process.env.FCM_PROJECT_ID!,
+    clientEmail: process.env.FCM_CLIENT_EMAIL!,
+    privateKey: process.env.FCM_PRIVATE_KEY!,
+  }),`,
+    },
+    apns: {
+        displayName: 'Apple Push Notification (Push)',
+        subpath: './apns',
+        factoryName: 'createApnsPushTransport',
+        appOption: 'push',
+        envVars: {
+            APNS_KEY_ID: 'your-key-id',
+            APNS_TEAM_ID: 'your-team-id',
+            APNS_PRIVATE_KEY: '-----BEGIN PRIVATE KEY-----\\n...\\n-----END PRIVATE KEY-----',
+            APNS_BUNDLE_ID: 'com.your.app',
+        },
+        peerDep: null,
+        importExample: `import { createApnsPushTransport } from '@objectifthunes/sandstone-sdk/apns';`,
+        wiringExample: `  push: createApnsPushTransport({
+    keyId: process.env.APNS_KEY_ID!,
+    teamId: process.env.APNS_TEAM_ID!,
+    privateKey: process.env.APNS_PRIVATE_KEY!,
+    bundleId: process.env.APNS_BUNDLE_ID!,
+  }),`,
+    },
+    socketio: {
+        displayName: 'Socket.io (Realtime)',
+        subpath: './socketio',
+        factoryName: 'createSocketIoRealtime',
+        appOption: 'realtime',
+        envVars: {},
+        peerDep: 'socket.io',
+        importExample: `import { createSocketIoRealtime } from '@objectifthunes/sandstone-sdk/socketio';`,
+        wiringExample: `  realtime: createSocketIoRealtime({ server: httpServer }),`,
+    },
+    pusher: {
+        displayName: 'Pusher (Realtime)',
+        subpath: './pusher',
+        factoryName: 'createPusherRealtime',
+        appOption: 'realtime',
+        envVars: {
+            PUSHER_APP_ID: 'your-app-id',
+            PUSHER_KEY: 'your-key',
+            PUSHER_SECRET: 'your-secret',
+            PUSHER_CLUSTER: 'us2',
+        },
+        peerDep: null,
+        importExample: `import { createPusherRealtime } from '@objectifthunes/sandstone-sdk/pusher';`,
+        wiringExample: `  realtime: createPusherRealtime({
+    appId: process.env.PUSHER_APP_ID!,
+    key: process.env.PUSHER_KEY!,
+    secret: process.env.PUSHER_SECRET!,
+    cluster: process.env.PUSHER_CLUSTER!,
+  }),`,
+    },
+    ably: {
+        displayName: 'Ably (Realtime)',
+        subpath: './ably',
+        factoryName: 'createAblyRealtime',
+        appOption: 'realtime',
+        envVars: {
+            ABLY_API_KEY: 'your-api-key',
+        },
+        peerDep: null,
+        importExample: `import { createAblyRealtime } from '@objectifthunes/sandstone-sdk/ably';`,
+        wiringExample: `  realtime: createAblyRealtime({ apiKey: process.env.ABLY_API_KEY! }),`,
+    },
+    'pg-search': {
+        displayName: 'PostgreSQL Full-Text Search',
+        subpath: './pg-search',
+        factoryName: 'createPgSearch',
+        appOption: 'search',
+        envVars: {},
+        peerDep: 'pg',
+        importExample: `import { createPgSearch } from '@objectifthunes/sandstone-sdk/pg-search';`,
+        wiringExample: `  search: createPgSearch({ db }),  // pass the DatabaseClient instance`,
+    },
+    'node-cron': {
+        displayName: 'node-cron (Scheduler Tick Source)',
+        subpath: './node-cron',
+        factoryName: 'createNodeCronTickSource',
+        appOption: 'scheduler (tickSource)',
+        envVars: {},
+        peerDep: 'node-cron',
+        importExample: `import { createNodeCronTickSource } from '@objectifthunes/sandstone-sdk/node-cron';`,
+        wiringExample: `  scheduler: { tickSource: createNodeCronTickSource() },`,
+    },
+    'local-storage': {
+        displayName: 'Local Filesystem (Storage)',
+        subpath: './local-storage',
+        factoryName: 'createLocalStorage',
+        appOption: 'storage',
+        envVars: {
+            STORAGE_DIR: './uploads',
+        },
+        peerDep: null,
+        importExample: `import { createLocalStorage } from '@objectifthunes/sandstone-sdk/local-storage';`,
+        wiringExample: `  storage: createLocalStorage({ directory: process.env.STORAGE_DIR ?? './uploads' }),`,
+    },
+};
+function parseArgs(args) {
+    const name = args.find((a) => !a.startsWith('-'));
+    if (!name) {
+        console.error('Error: Adapter name is required.');
+        console.error('Usage: sandstone add adapter <name>');
+        console.error();
+        console.error('Available adapters:');
+        const sorted = Object.entries(KNOWN_ADAPTERS).sort(([a], [b]) => a.localeCompare(b));
+        for (const [key, info] of sorted) {
+            console.error(`  ${key.padEnd(18)} ${info.displayName}`);
+        }
+        process.exit(1);
+    }
+    return { name };
+}
+async function updateEnvExample(envVars) {
+    const envPath = join(process.cwd(), '.env.example');
+    if (!existsSync(envPath)) {
+        return false;
+    }
+    const content = await readFile(envPath, 'utf-8');
+    const lines = content.split('\n');
+    const existingKeys = new Set(lines
+        .filter((l) => l.includes('=') && !l.startsWith('#'))
+        .map((l) => l.split('=')[0].trim()));
+    const newVars = [];
+    for (const [key, value] of Object.entries(envVars)) {
+        if (!existingKeys.has(key)) {
+            newVars.push(`${key}=${value}`);
+        }
+    }
+    if (newVars.length === 0) {
+        return false;
+    }
+    const updatedContent = content.trimEnd() + '\n\n# Added by: sandstone add adapter\n' + newVars.join('\n') + '\n';
+    await writeFile(envPath, updatedContent, 'utf-8');
+    return true;
+}
+export async function addAdapter(args) {
+    const { name } = parseArgs(args);
+    const adapter = KNOWN_ADAPTERS[name];
+    if (!adapter) {
+        console.error(`\n  Unknown adapter: "${name}"\n`);
+        console.error('  Available adapters:');
+        const sorted = Object.entries(KNOWN_ADAPTERS).sort(([a], [b]) => a.localeCompare(b));
+        for (const [key, info] of sorted) {
+            console.error(`    ${key.padEnd(18)} ${info.displayName}`);
+        }
+        console.error();
+        console.error('  To create a custom adapter, use: sandstone generate adapter <name> --port <PortName>');
+        process.exit(1);
+    }
+    // Update .env.example if it exists
+    const envVarEntries = Object.entries(adapter.envVars);
+    let envUpdated = false;
+    if (envVarEntries.length > 0) {
+        envUpdated = await updateEnvExample(adapter.envVars);
+    }
+    // Print wiring instructions
+    console.log(`\n  Add adapter: ${adapter.displayName}\n`);
+    if (adapter.peerDep) {
+        console.log(`  1. Install peer dependency:\n`);
+        console.log(`    npm install ${adapter.peerDep}\n`);
+    }
+    else {
+        console.log(`  1. No peer dependency needed (uses fetch or built-in modules).\n`);
+    }
+    console.log(`  2. Import in src/infrastructure.ts:\n`);
+    console.log(`    ${adapter.importExample}\n`);
+    console.log(`  3. Add to createApp() options:\n`);
+    console.log(adapter.wiringExample
+        .split('\n')
+        .map((line) => `    ${line}`)
+        .join('\n'));
+    console.log();
+    if (envVarEntries.length > 0) {
+        console.log(`  4. Environment variables needed:\n`);
+        for (const [key, value] of envVarEntries) {
+            console.log(`    ${key}=${value}`);
+        }
+        console.log();
+        if (envUpdated) {
+            console.log(`  .env.example has been updated with missing variables.\n`);
+        }
+        else if (existsSync(join(process.cwd(), '.env.example'))) {
+            console.log(`  All environment variables already present in .env.example.\n`);
+        }
+        else {
+            console.log(`  No .env.example found. Add these variables to your .env file manually.\n`);
+        }
+    }
+}
+//# sourceMappingURL=add-adapter.js.map