chore: wip

Author: glennmichael123

app/Actions/Billable/CheckoutAction.ts

@@ -8,7 +8,7 @@ export default new Action({
   description: 'Checkout Action',
   method: 'POST',
   async handle(request: RequestInstance) {
-    const user = request.user()
+    const user = await request.user()
 
     if (!user) {
       return response.json({ message: 'User not found' }, 404)
@@ -19,8 +19,8 @@ export default new Action({
       cancel_url: 'https://localhost:3000/cancel',
     }
 
-    const checkout = await manageCheckout.create(user, params)
+    const session = await manageCheckout.create(user, params)
 
-    return response.json({ message: 'Category deleted successfully' })
+    return response.json({ url: session.url })
   },
 })

storage/framework/core/config/src/config.ts

@@ -5,7 +5,7 @@ import { overrides } from './overrides'
 
 // merged defaults and overrides
 export const config: StacksOptions = {
-  ...defaults,
+  // ...defaults,
   ...overrides,
 }
 

storage/framework/core/env/src/types.ts

@@ -1,5 +1,4 @@
-import type { Infer, VineBoolean, VineEnum, VineNumber, VineString } from '@stacksjs/validation'
-import type { SchemaTypes } from '@vinejs/vine/types'
+import type { BooleanValidatorType, EnumValidatorType, NumberValidatorType, StringValidatorType, ValidationType } from '@stacksjs/ts-validation'
 import type { EnvKey } from '../../../env'
 import { schema } from '@stacksjs/validation'
 import env from '~/config/env'
@@ -17,76 +16,79 @@ export const envEnum: EnumObject = {
 }
 
 interface StringEnvConfig {
-  validation: VineString
+  validation: StringValidatorType
   default: string
 }
 
 interface NumberEnvConfig {
-  validation: VineNumber
+  validation: NumberValidatorType
   default: number
 }
 
 interface BooleanEnvConfig {
-  validation: VineBoolean
+  validation: BooleanValidatorType
   default: boolean
 }
 
 interface EnumEnvConfig {
-  validation: VineEnum<any>
+  validation: EnumValidatorType<string>
   default: string
 }
 
 type EnvValueConfig = StringEnvConfig | NumberEnvConfig | BooleanEnvConfig | EnumEnvConfig
 
 export type EnvConfig = Partial<Record<EnvKey, EnvValueConfig>>
 
-type EnvMap = Record<string, SchemaTypes>
+type EnvMap = Record<string, string>
+
+type TypeFromString<T extends string> = T extends 'string' 
+  ? string 
+  : T extends 'number' 
+    ? number 
+    : T extends 'boolean' 
+      ? boolean 
+      : T extends 'enum' 
+        ? string 
+        : never
+
+type Infer<T extends Record<string, string>> = {
+  [K in keyof T]: TypeFromString<T[K]>
+}
 
 const envStructure: EnvMap = Object.entries(env).reduce((acc, [key, value]) => {
   if (typeof value === 'object' && value !== null && 'validation' in value) {
-    acc[key] = (value as EnvValueConfig).validation
+    acc[key] = (value as EnvValueConfig).validation.name
     return acc
   }
 
-  let validatorType: SchemaTypes
+  let typeName: string
   switch (typeof value) {
     case 'string':
-      validatorType = schema.string()
+      typeName = 'string'
       break
     case 'number':
-      validatorType = schema.number()
+      typeName = 'number'
       break
     case 'boolean':
-      validatorType = schema.boolean()
+      typeName = 'boolean'
       break
     default:
       if (Array.isArray(value)) {
-        validatorType = schema.enum(value as string[])
+        typeName = 'enum'
         break
       }
 
       // check if is on object
       if (typeof value === 'object' && value !== null) {
-        const schemaNameSymbol = Symbol.for('schema_name')
-        const schemaName = (value as { [key: symbol]: string })[schemaNameSymbol]
-
-        if (schemaName === 'vine.string') {
-          validatorType = schema.string()
-          break
-        }
+        const schemaName = (value as { name: string }).name
 
-        if (schemaName === 'vine.number') {
-          validatorType = schema.number()
-          break
-        }
-
-        if (schemaName === 'vine.boolean') {
-          validatorType = schema.boolean()
+        if (schemaName === 'string' || schemaName === 'number' || schemaName === 'boolean') {
+          typeName = schemaName
           break
         }
 
         if (!schemaName && key in envEnum) {
-          validatorType = schema.enum(envEnum[key as keyof typeof envEnum])
+          typeName = 'enum'
           break
         }
 
@@ -96,14 +98,15 @@ const envStructure: EnvMap = Object.entries(env).reduce((acc, [key, value]) => {
       throw new Error(`Invalid env value for ${key}`)
   }
 
-  acc[key] = validatorType
+  acc[key] = typeName
   return acc
-}, {} as EnvMap)
+}, {} as Record<string, string>)
 
-export const envSchema: ReturnType<typeof schema.object> = schema.object(envStructure)
-export type Env = Infer<typeof envSchema>
+export type Env = {
+  [K in keyof typeof envStructure]: typeof envStructure[K]
+}
 
-export type EnvOptions = Env
+export type EnvSchema = ReturnType<typeof schema.object<typeof envStructure>>
 
 export interface FrontendEnv {
   FRONTEND_APP_ENV: 'local' | 'development' | 'staging' | 'production'