// adonisrc.ts
export default defineConfig({
  providers: [
    // ... other providers
    () => import('@mixxtor/adonisjs-shopify/providers/shopify_provider')
  ]
})

import { defineConfig } from '@mixxtor/adonisjs-shopify'
import { RestResources } from '@shopify/shopify-api/rest/admin/2025-07'
import env from '#start/env'

// Extend the container types for proper REST resource type inference
declare module '@mixxtor/adonisjs-shopify/types' {
  interface ShopifyRestResources extends RestResources {}
}

const shopifyConfig = defineConfig({
  api_key: env.get('SHOPIFY_API_KEY'),
  api_secret: env.get('SHOPIFY_API_SECRET'),
  api_version: env.get('SHOPIFY_API_VERSION', '2025-01'),
  host_name: env.get('SHOPIFY_HOST_NAME'),
  scopes: env.get('SHOPIFY_SCOPES', '').split(','),
  is_embedded_app: true,
  is_private_app: false,
  // Add other Shopify configuration options as needed
})

export default shopifyConfig

import app from '@adonisjs/core/services/app'

export const shopify = await app.container.make('shopify')

// In your services/controllers
import { inject } from '@adonisjs/core'
import type { ShopifyService } from '@mixxtor/adonisjs-shopify/types'

@inject()
export default class ProductService {
  constructor(private shopify: ShopifyService) {}

  async getProducts(session: Session) {
    // Full type inference for Product class
    const products = await this.shopify.api.rest.Product.all({ session })
    return products.data
  }

  async createProduct(session: Session, productData: any) {
    const product = new this.shopify.api.rest.Product({ session })
    product.title = productData.title
    product.body_html = productData.description
    
    await product.save()
    return product
  }
}

// Alternative: Import service directly
import shopify from '@mixxtor/adonisjs-shopify/services/main'

export default class ShopController {
  async index({ session }: HttpContext) {
    const products = await shopify.api.rest.Product.all({ 
      session: session.shopifySession 
    })
    
    return products.data
  }
}

import { inject } from '@adonisjs/core'
import type { HttpContext } from '@adonisjs/core/http'

@inject()
export default class AuthController {
  constructor(private shopify: ShopifyService) {}

  async redirect({ request, response }: HttpContext) {
    const shop = request.input('shop')
    
    const authUrl = await this.shopify.auth.begin({
      shop,
      callbackPath: '/auth/callback',
      isOnline: false
    })
    
    return response.redirect(authUrl)
  }

  async callback({ request, response }: HttpContext) {
    const authResult = await this.shopify.auth.callback({
      rawRequest: request.request,
      rawResponse: response.response
    })
    
    if (authResult.session) {
      // Store session and redirect to app
      return response.redirect('/dashboard')
    }
    
    return response.badRequest('Authentication failed')
  }
}

import type { HttpContext } from '@adonisjs/core/http'

export default class WebhookController {
  async handle({ request, response }: HttpContext) {
    try {
      const isValid = await shopify.webhooks.validate({
        rawBody: request.raw(),
        rawRequest: request.request
      })
      
      if (!isValid) {
        return response.unauthorized()
      }
      
      const topic = request.header('x-shopify-topic')
      const payload = request.body()
      
      // Handle webhook based on topic
      switch (topic) {
        case 'orders/create':
          await this.handleOrderCreate(payload)
          break
        case 'products/update':
          await this.handleProductUpdate(payload)
          break
      }
      
      return response.ok()
    } catch (error) {
      return response.internalServerError()
    }
  }
}