asasvirtuais 0.1.0

package/packages/next.ts

@@ -0,0 +1,64 @@
+import { ReactNode } from 'react'
+import { ImageResponse } from 'next/og'
+import  { NextRequest, NextResponse } from 'next/server'
+import { parse } from 'search-params'
+
+type NextRouteProps<Params = {}> = {request: NextRequest} & Params
+type NextRouteHandler<Params = {}> = (props: NextRouteProps<Params>) => Promise<NextResponse<any> | Response | ImageResponse | object | unknown>
+type NextLayoutHandler<SP = {}> = (props: SP) => Promise<ReactNode>
+type NextPageHandler<Params = {}> = (params: Params) => Promise<ReactNode>
+
+export const route = <P = {}>(handler: NextRouteHandler<P>) : any => (
+    async (request: NextRequest, { params: promise }: { params: Promise<P> } ) => {
+        const params = await promise
+        const query = parse(request.nextUrl.search)
+        return handler({request, ...params, ...query})
+        .then(
+            response => {
+                if (response instanceof NextResponse)
+                    return response
+                else if (response instanceof Response)
+                    return response
+                else if (response instanceof ImageResponse)
+                    return response
+                return NextResponse.json(response)
+            }
+        )
+        .catch(
+            error => {
+                console.error(error, request, params)
+                return NextResponse.json({
+                    request: JSON.stringify(request),
+                    params,
+                    error: {
+                        name: error.name,
+                        message: error.message,
+                        cause: error.cause,
+                        stack: error.stack,
+                    },
+                }, { url: request.url, status: 500 })
+            }
+        )
+    }
+)
+
+export const layout = <SlotsAndParams = {}>( handler: NextLayoutHandler<SlotsAndParams & { children: React.ReactNode }> ): any => (
+    async ({params, ...slots}: { params: Promise<any>, children: ReactNode }) => (
+        handler({ ...slots, ...(params ? await params : {}) } as SlotsAndParams & { children: React.ReactNode })
+    )
+)
+export const page = <Params = {}>( handler: NextPageHandler<Params>): any => (
+    async ({params, searchParams}: { params: Promise<any>, searchParams: Promise<any> }) => handler({
+        ...(await params), ...(await searchParams)
+    })
+)
+export const redirect = (url: string, auth?: string) => (
+    new NextResponse(null, {
+        status: 302,
+        headers: {
+            Location: url,
+            ...(auth ? { Authorization: auth } : {})
+        }
+    })
+)
+

package/packages/openrouter.ts

@@ -0,0 +1,4 @@
+import { createOpenRouter } from '@openrouter/ai-sdk-provider'
+const openrouter = createOpenRouter({ apiKey: process.env.OPENROUTER_API_KEY })
+
+export default openrouter

package/packages/react/context.tsx

@@ -0,0 +1,21 @@
+'use client'
+
+import React from 'react'
+
+export function createContextFromHook<Props, Result>(useHook: (props: Props) => Result) {
+
+    const Context = React.createContext<Result | undefined>(undefined)
+
+    function Provider( { children, ...props}: React.PropsWithChildren<Props> ) {
+
+        const value = useHook(props as Props) as Result
+
+        return <Context.Provider value={value}>{ children }</Context.Provider>
+    }
+
+    function useContext() {
+        return React.useContext(Context) as Result
+    }
+
+    return [Provider, useContext] as const
+}

package/packages/react/crud.tsx

@@ -0,0 +1,372 @@
+"use client"
+import { z } from "zod"
+import {
+  useState,
+  useCallback,
+  useEffect,
+  useMemo,
+  createContext,
+  useContext,
+} from "react"
+import { TableInterface, ListProps } from "@/packages/crud"
+import { createContextFromHook } from "./context"
+import { useIndex } from "./hooks"
+import { FieldsProvider, useFields } from "@/packages/fields"
+import { FormProvider, useForm, useFormProvider } from "@/packages/form"
+
+export function database<
+  Database extends Record<
+    string,
+    { readable: z.SomeZodObject; writable: z.SomeZodObject }
+  >
+>(
+  database: Database,
+  {
+    find,
+    create,
+    update,
+    remove,
+    list,
+  }: TableInterface<
+    z.infer<Database[keyof Database]["readable"]>,
+    z.infer<Database[keyof Database]["writable"]>
+  >
+) {
+  type TableKey = keyof Database & string
+
+  function useTableProvider<Table extends TableKey>({
+    table,
+    asAbove,
+  }: {
+    table: Table
+    asAbove?: Record<string, z.infer<Database[Table]["readable"]>>
+  }) {
+    type Readable = z.infer<Database[Table]["readable"]>
+    type Writable = z.infer<Database[Table]["writable"]>
+
+    const index = useIndex<Readable>({ ...(asAbove ?? {}) })
+
+    const array = useMemo(
+      () => Object.values(index.index) as Readable[],
+      [index.index]
+    )
+
+    useEffect(function soBelow() {
+      index.setIndex((prev) => ({ ...prev, ...asAbove }))
+    }, [])
+
+    const methods = { find, create, update, remove, list } as TableInterface<
+      Readable,
+      Writable
+    >
+
+    // Create wrapped method that updates the index after successful operations
+    const createWithIndex = useCallback(
+      (async (props) => {
+        const result = await methods.create({ ...props, table })
+        if (result && (result).id) {
+          index.set(result as Readable)
+        }
+        return result
+      }) as typeof create,
+      [methods, table, index]
+    )
+
+    const updateWithIndex = useCallback(
+      (async (props) => {
+        const result = await methods.update({ ...props, table })
+        if (result && (result).id) {
+          index.set(result as Readable)
+        }
+        return result
+      }) as typeof update,
+      [methods, table, index]
+    )
+
+    const removeWithIndex = useCallback(
+      (async (props) => {
+        const result = await methods.remove({ ...props, table })
+        if (result && (result).id) {
+          index.remove(result as Readable)
+        }
+        return result
+      }) as typeof remove,
+      [methods, table, index]
+    )
+
+    const listWithIndex = useCallback(
+      (async (props) => {
+        const result = await methods.list({ ...props, table })
+        if (Array.isArray(result)) {
+          index.setIndex(
+            Object.fromEntries(result.map((item) => [(item).id, item]))
+          )
+        }
+        return result
+      }) as typeof list,
+      [methods, table, index]
+    )
+
+    return {
+      ...index,
+      array,
+      find: useMethod((props) => methods.find({ ...props, table })),
+      create: useMethod(createWithIndex),
+      update: useMethod(updateWithIndex),
+      remove: useMethod(removeWithIndex),
+      list: useMethod(listWithIndex),
+    }
+  }
+
+  function useDatabaseProvider(tables: {
+    [T in TableKey]: ReturnType<typeof useTableProvider<T>>
+  }) {
+    return tables
+  }
+
+  const [DatabaseProvider, useDatabase] =
+    createContextFromHook(useDatabaseProvider)
+
+  function useTable<T extends TableKey>(name: T) {
+    return useDatabase()[name]
+  }
+
+  function useSingleProvider<Table extends TableKey>({
+    id,
+    table,
+  }: {
+    id: string
+    table: Table
+  }) {
+    const { index, find } = useTable(table)
+    const [single, setSingle] = useState<z.infer<Database[Table]["readable"]>>(
+      () => index[id]
+    )
+    useEffect(() => {
+      if (!single) find.trigger({ id }).then(setSingle)
+    }, [])
+    useEffect(() => {
+      setSingle(index[id])
+    }, [index[id]])
+    return {
+      id,
+      single,
+      setSingle,
+      loading: find.loading,
+    }
+  }
+
+  const SingleContext = createContext<
+    ReturnType<typeof useSingleProvider<any>> | undefined
+  >(undefined)
+
+  function SingleProvider<Table extends TableKey>({
+    children,
+    ...props
+  }: {
+    id: string
+    table: Table
+    children: React.ReactNode
+  }) {
+    const value = useSingleProvider(props)
+    if (!value.single) return null
+    return (
+      <SingleContext.Provider value={value}>{children}</SingleContext.Provider>
+    )
+  }
+
+  const useSingle = <Table extends TableKey>() =>
+    useContext(SingleContext) as ReturnType<typeof useSingleProvider<Table>>
+
+  function CreateForm<
+    T extends TableKey
+  >({
+    table,
+    defaults,
+    onSuccess,
+    children,
+  }: {
+    table: T
+    defaults?: Partial<z.infer<Database[T]["writable"]>>
+    onSuccess?: (result: z.infer<Database[T]["readable"]>) => void
+    children: (props: ReturnType<typeof useFormProvider<z.infer<Database[T]["writable"]>, z.infer<Database[T]["readable"]>>>) => React.ReactNode
+  }) {
+    type Readable = z.infer<Database[T]["readable"]>
+    type Writable = z.infer<Database[T]["writable"]>
+
+    const { create } = useTable(table)
+
+    const callback = useCallback(
+      async (fields: Writable) => {
+        const result = await create.trigger({ data: fields })
+        if (onSuccess) onSuccess(result as Readable)
+        return result
+      },
+      [create, onSuccess]
+    )
+
+    return (
+      <FieldsProvider<Writable> defaults={defaults || ({} as Writable)}>
+        {fields => (
+          <FormProvider<Writable, Readable> callback={callback} data={fields.fields}>
+            {form => children({...form, ...fields})}
+          </FormProvider>
+        )}
+      </FieldsProvider>
+    )
+  }
+
+  function UpdateForm<T extends TableKey>({
+    table,
+    id,
+    defaults,
+    onSuccess,
+    children,
+  }: {
+    table: TableKey
+    id: string
+    defaults?: Partial<z.infer<Database[TableKey]["writable"]>>
+    onSuccess?: (result: z.infer<Database[TableKey]["readable"]>) => void
+    children: (props: ReturnType<typeof useFormProvider<z.infer<Database[T]["writable"]>, z.infer<Database[T]["readable"]>>>) => React.ReactNode
+  }) {
+    type Readable = z.infer<Database[T]["readable"]>
+    type Writable = z.infer<Database[T]["writable"]>
+
+    const { update } = useTable(table)
+
+    const callback = useCallback(
+      async (fields: Partial<Writable>) => {
+        const result = await update.trigger({ id, data: fields })
+        if (onSuccess) onSuccess(result as Readable)
+        return result
+      },
+      [update, id, onSuccess]
+    )
+
+    return (
+      <FieldsProvider<Partial<Writable>>
+        defaults={defaults || ({} as Partial<Writable>)}
+      >
+        {fields => (
+          <FormProvider<Partial<Writable>, Readable> callback={callback} data={fields.fields}>
+            {form => children({...form, ...fields})}
+          </FormProvider>
+        )}
+      </FieldsProvider>
+    )
+  }
+
+  function FilterForm<T extends TableKey>({
+    table,
+    defaults,
+    onSuccess,
+    children,
+  }: {
+    table: T
+    defaults?: Partial<ListProps<z.infer<Database[T]["readable"]>>>
+    onSuccess?: (result: z.infer<Database[T]["readable"]>[]) => void
+    children: (props: ReturnType<typeof useFormProvider<z.infer<Database[T]["writable"]>, z.infer<Database[T]["readable"]>>>) => React.ReactNode
+  }) {
+    type Readable = z.infer<Database[T]["readable"]>
+    type Writable = z.infer<Database[T]["writable"]>
+
+    const { list } = useTable(table)
+
+    const callback = useCallback(
+      async (fields: Omit<ListProps<Readable>, "table">) => {
+        const result = await list.trigger(fields)
+        if (onSuccess) onSuccess(result)
+        return result
+      },
+      [list, onSuccess]
+    )
+
+    return (
+      <FieldsProvider<ListProps<Readable>>
+        defaults={(defaults || {}) as ListProps<Readable>}
+      >
+        {fields => (
+          <FormProvider<ListProps<Readable>, Readable[]> callback={callback} data={fields.fields}>
+            {form => children({...form, ...fields})}
+          </FormProvider>
+        )}
+      </FieldsProvider>
+    )
+  }
+
+  const useCreateForm = <T extends TableKey>(table: T) => {
+    return {
+      ...useFields<z.infer<Database[T]["writable"]>>(),
+      ...useForm<
+        z.infer<Database[T]["writable"]>,
+        z.infer<Database[T]["readable"]>
+      >(),
+    }
+  }
+  const useUpdateForm = <T extends TableKey>(table: T) => {
+    return {
+      ...useFields<Partial<z.infer<Database[T]["writable"]>>>(),
+      ...useForm<
+        Partial<z.infer<Database[T]["writable"]>>,
+        z.infer<Database[T]["readable"]>
+      >(),
+    }
+  }
+  const useFiltersForm = <T extends TableKey>(table: T) => {
+    return {
+      ...useFields<ListProps<z.infer<Database[T]["readable"]>>>(),
+      ...useForm<
+        ListProps<z.infer<Database[T]["readable"]>>,
+        z.infer<Database[T]["readable"]>[]
+      >(),
+    }
+  }
+
+  return {
+    DatabaseProvider,
+    useDatabase,
+    useTable,
+    useTableProvider,
+    SingleProvider,
+    useSingle,
+    CreateForm,
+    UpdateForm,
+    FilterForm,
+    useCreateForm,
+    useUpdateForm,
+    useFiltersForm,
+  }
+}
+
+function useMethod<Fn extends (props: any) => Promise<any>>(method: Fn) {
+  const [loading, setLoading] = useState(false)
+  const [error, setError] = useState<Error | null>(null)
+  const [result, setResult] = useState<Awaited<ReturnType<Fn>>>()
+
+  const trigger = useCallback(
+    (async (props) => {
+      if (loading) return
+      setLoading(true)
+      setError(null)
+      try {
+        const data = await method(props)
+        setResult(data)
+        return data
+      } catch (err) {
+        console.error("CRUD operation failed:", err)
+        setError(err as Error)
+        throw err
+      } finally {
+        setLoading(false)
+      }
+    }) as typeof method,
+    [method, loading]
+  )
+
+  return {
+    trigger,
+    loading,
+    error,
+    result,
+  }
+}

package/packages/react/hooks.ts

@@ -0,0 +1,90 @@
+'use client'
+
+import { useCallback, useEffect, useMemo, useState } from 'react'
+
+export function useAction<Props, Result, Defaults = Partial<Props>>(action: (props: Props) => Promise<Result>, {
+    onSuccess,
+    autoTrigger,
+    ...props
+} : {
+    defaults?: Defaults
+    onSuccess?: (result: Result, props?: Props) => void
+    autoTrigger?: boolean
+} = {}) {
+    const [loading, setLoading] = useState<boolean>(false)
+    const [error, setError] = useState()
+    const [result, setResult] = useState<Result>()
+    const [defaults, setDefaults] = useState<Defaults>(props.defaults ?? {} as Defaults)
+
+    const trigger = useCallback(async (props: Omit<Props, keyof Defaults>): Promise<Result> => {
+        try {
+            setLoading(true)
+            const result = await action({
+                ...props,
+                ...defaults,
+            } as Props)
+
+            setResult(result)
+            if (onSuccess)
+                onSuccess(result)
+            return result
+
+        } catch (error) {
+            // @ts-expect-error
+            setError(error)
+            throw error
+        } finally {
+            setLoading(false)
+        }
+    }, [defaults, onSuccess, loading, setLoading])
+
+    useEffect(() => {
+        if (autoTrigger)
+            trigger(props as Omit<Props, keyof Defaults>)
+    }, [])
+
+    return {
+        trigger,
+        loading,
+        error,
+        result,
+        defaults,
+        setDefaults,
+    }
+}
+
+export function useIndex<T>(value: Record<string, any>) {
+
+    type readable = T
+
+    const [index, setIndex] = useState<Record<string, T>>(() => value)
+
+    const array = useMemo(() => Object.values(index) as readable[], [index])
+
+    const set = useCallback((...params: readable[]) => {
+        setIndex(prev => ({
+            ...prev,
+            ...Object.fromEntries(params.map(data => ([(data as readable & { id: string }).id, data])))
+        }))
+    }, [])
+
+    const remove = useCallback((...params: readable[]) => {
+        setIndex(prev => {
+            const newState = { ...prev }
+            for ( const data of params ) {
+                const id = (data as readable & { id: string }).id
+                if (newState[id])
+                    delete newState[id]
+            }
+            return newState
+        })
+    }, [])
+
+    return {
+        index,
+        array,
+        set,
+        setIndex,
+        remove,
+    }
+}

package/packages/react/store.tsx

@@ -0,0 +1,20 @@
+'use client'
+
+import { useIndex } from './hooks'
+import { createContextFromHook } from './context'
+
+type StoreProps<T> = {
+    [table: string]: (T & { id: string })[]
+}
+
+function useStoreProvider<T>(props : StoreProps<T>) {
+    return Object.fromEntries(
+        Object.entries(props).map(
+            ([table, initial]) => [table, useIndex<T>({ initial: initial as T & { id: string }[] })]
+        )
+    ) as {
+        [table: string]: ReturnType<typeof useIndex<T>>
+    }
+}
+
+export const [StoreProvider, useStore] = createContextFromHook(useStoreProvider<any>)