@pyreon/feature 0.11.5 → 0.11.7

package/src/define-feature.ts

@@ -1,19 +1,19 @@
-import type { SchemaValidateFn } from "@pyreon/form"
-import { useForm as _useForm } from "@pyreon/form"
-import type { QueryKey } from "@pyreon/query"
-import { useMutation as _useMutation, useQuery as _useQuery, useQueryClient } from "@pyreon/query"
-import { batch, signal } from "@pyreon/reactivity"
-import { defineStore } from "@pyreon/store"
-import type { ColumnDef, SortingState } from "@pyreon/table"
+import type { SchemaValidateFn } from '@pyreon/form'
+import { useForm as _useForm } from '@pyreon/form'
+import type { QueryKey } from '@pyreon/query'
+import { useMutation as _useMutation, useQuery as _useQuery, useQueryClient } from '@pyreon/query'
+import { batch, signal } from '@pyreon/reactivity'
+import { defineStore } from '@pyreon/store'
+import type { ColumnDef, SortingState } from '@pyreon/table'
 import {
   useTable as _useTable,
   getCoreRowModel,
   getFilteredRowModel,
   getPaginationRowModel,
   getSortedRowModel,
-} from "@pyreon/table"
-import { zodSchema } from "@pyreon/validation"
-import { defaultInitialValues, extractFields } from "./schema"
+} from '@pyreon/table'
+import { zodSchema } from '@pyreon/validation'
+import { defaultInitialValues, extractFields } from './schema'
 import type {
   Feature,
   FeatureConfig,
@@ -21,7 +21,7 @@ import type {
   FeatureStore,
   FeatureTableOptions,
   ListOptions,
-} from "./types"
+} from './types'
 
 // ─── Fetch wrapper ────────────────────────────────────────────────────────────
 
@@ -30,7 +30,7 @@ function createFetcher(baseFetcher: typeof fetch = fetch) {
     const res = await baseFetcher(url, init)
 
     if (!res.ok) {
-      let message = `${init?.method ?? "GET"} ${url} failed: ${res.status}`
+      let message = `${init?.method ?? 'GET'} ${url} failed: ${res.status}`
       try {
         const body = await res.json()
         if (body?.message) message = body.message
@@ -41,7 +41,7 @@ function createFetcher(baseFetcher: typeof fetch = fetch) {
           })
         }
       } catch (e) {
-        if (e instanceof Error && "errors" in e) throw e
+        if (e instanceof Error && 'errors' in e) throw e
       }
       throw Object.assign(new Error(message), { status: res.status })
     }
@@ -54,7 +54,7 @@ function createFetcher(baseFetcher: typeof fetch = fetch) {
     list<T>(url: string, params?: Record<string, string | number | boolean>): Promise<T[]> {
       const query = params
         ? `?${new URLSearchParams(Object.entries(params).map(([k, v]) => [k, String(v)])).toString()}`
-        : ""
+        : ''
       return request<T[]>(`${url}${query}`)
     },
     getById<T>(url: string, id: string | number): Promise<T> {
@@ -62,20 +62,20 @@ function createFetcher(baseFetcher: typeof fetch = fetch) {
     },
     create<T>(url: string, data: unknown): Promise<T> {
       return request<T>(url, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify(data),
       })
     },
     update<T>(url: string, id: string | number, data: unknown): Promise<T> {
       return request<T>(`${url}/${id}`, {
-        method: "PUT",
-        headers: { "Content-Type": "application/json" },
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify(data),
       })
     },
     delete(url: string, id: string | number): Promise<void> {
-      return request<void>(`${url}/${id}`, { method: "DELETE" })
+      return request<void>(`${url}/${id}`, { method: 'DELETE' })
     },
   }
 }
@@ -90,9 +90,9 @@ function createValidator<TValues extends Record<string, unknown>>(
 
   if (
     schema &&
-    typeof schema === "object" &&
-    "safeParseAsync" in schema &&
-    typeof (schema as Record<string, unknown>).safeParseAsync === "function"
+    typeof schema === 'object' &&
+    'safeParseAsync' in schema &&
+    typeof (schema as Record<string, unknown>).safeParseAsync === 'function'
   ) {
     return zodSchema(schema as Parameters<typeof zodSchema>[0]) as SchemaValidateFn<TValues>
   }
@@ -104,7 +104,7 @@ function createValidator<TValues extends Record<string, unknown>>(
 
 function resolvePageValue(page: number | (() => number) | undefined): number | undefined {
   if (page === undefined) return undefined
-  if (typeof page === "function") return page()
+  if (typeof page === 'function') return page()
   return page
 }
 
@@ -197,7 +197,7 @@ export function defineFeature<TValues extends Record<string, unknown>>(
           params.pageSize = pageSize
         }
 
-        const queryKeyParts: unknown[] = [...queryKeyBase, "list", params]
+        const queryKeyParts: unknown[] = [...queryKeyBase, 'list', params]
 
         return {
           queryKey: queryKeyParts as QueryKey,
@@ -219,7 +219,7 @@ export function defineFeature<TValues extends Record<string, unknown>>(
 
     useSearch(searchTerm, options?: ListOptions) {
       return _useQuery(() => ({
-        queryKey: [...queryKeyBase, "search", searchTerm()],
+        queryKey: [...queryKeyBase, 'search', searchTerm()],
         queryFn: () => http.list<TValues>(api, { ...options?.params, q: searchTerm() }),
         enabled: searchTerm().length > 0,
         ...(options?.staleTime != null ? { staleTime: options.staleTime } : {}),
@@ -249,7 +249,7 @@ export function defineFeature<TValues extends Record<string, unknown>>(
           await client.cancelQueries({ queryKey: [name, variables.id] })
           const previous = client.getQueryData([name, variables.id])
           client.setQueryData([name, variables.id], (old: unknown) => {
-            if (old && typeof old === "object") {
+            if (old && typeof old === 'object') {
               return { ...old, ...variables.data }
             }
             return variables.data
@@ -267,7 +267,7 @@ export function defineFeature<TValues extends Record<string, unknown>>(
           })
           client.invalidateQueries({ queryKey: [name, variables.id] })
         },
-      }) as ReturnType<Feature<TValues>["useUpdate"]>
+      }) as ReturnType<Feature<TValues>['useUpdate']>
     },
 
     useDelete() {
@@ -285,7 +285,7 @@ export function defineFeature<TValues extends Record<string, unknown>>(
     // ─── Form ───────────────────────────────────────────────────────
 
     useForm(options?: FeatureFormOptions<TValues>) {
-      const mode = options?.mode ?? "create"
+      const mode = options?.mode ?? 'create'
       const mergedInitial = {
         ...initialValues,
         ...(options?.initialValues ?? {}),
@@ -294,11 +294,11 @@ export function defineFeature<TValues extends Record<string, unknown>>(
       const form = _useForm<TValues>({
         initialValues: mergedInitial,
         ...(validate != null ? { schema: validate } : {}),
-        validateOn: options?.validateOn ?? "blur",
+        validateOn: options?.validateOn ?? 'blur',
         onSubmit: async (values) => {
           try {
             let result: unknown
-            if (mode === "edit" && options?.id !== undefined) {
+            if (mode === 'edit' && options?.id !== undefined) {
               result = await http.update<TValues>(api, options.id, values)
             } else {
               result = await http.create<TValues>(api, values)
@@ -312,7 +312,7 @@ export function defineFeature<TValues extends Record<string, unknown>>(
       })
 
       // Auto-fetch in edit mode
-      if (mode === "edit" && options?.id !== undefined) {
+      if (mode === 'edit' && options?.id !== undefined) {
         form.isSubmitting.set(true)
         http.getById<TValues>(api, options.id).then(
           (data) => {
@@ -349,10 +349,10 @@ export function defineFeature<TValues extends Record<string, unknown>>(
       }))
 
       const sorting = signal<SortingState>([])
-      const globalFilter = signal("")
+      const globalFilter = signal('')
 
       const table = _useTable(() => ({
-        data: typeof data === "function" ? data() : data,
+        data: typeof data === 'function' ? data() : data,
         columns,
         state: {
           sorting: sorting(),
@@ -360,14 +360,14 @@ export function defineFeature<TValues extends Record<string, unknown>>(
         },
         onSortingChange: (updater: unknown) => {
           sorting.set(
-            typeof updater === "function"
+            typeof updater === 'function'
               ? (updater as (prev: SortingState) => SortingState)(sorting())
               : (updater as SortingState),
           )
         },
         onGlobalFilterChange: (updater: unknown) => {
           globalFilter.set(
-            typeof updater === "function"
+            typeof updater === 'function'
               ? (updater as (prev: string) => string)(globalFilter())
               : (updater as string),
           )

package/src/index.ts

@@ -1,11 +1,6 @@
-export { defineFeature } from "./define-feature"
-export type { FieldInfo, FieldType, ReferenceSchema } from "./schema"
-export {
-  defaultInitialValues,
-  extractFields,
-  isReference,
-  reference,
-} from "./schema"
+export { defineFeature } from './define-feature'
+export type { FieldInfo, FieldType, ReferenceSchema } from './schema'
+export { defaultInitialValues, extractFields, isReference, reference } from './schema'
 export type {
   Feature,
   FeatureConfig,
@@ -15,4 +10,4 @@ export type {
   FeatureTableResult,
   InferSchemaValues,
   ListOptions,
-} from "./types"
+} from './types'

package/src/schema.ts

@@ -21,18 +21,18 @@ export interface FieldInfo {
 }
 
 export type FieldType =
-  | "string"
-  | "number"
-  | "boolean"
-  | "date"
-  | "enum"
-  | "array"
-  | "object"
-  | "reference"
-  | "unknown"
+  | 'string'
+  | 'number'
+  | 'boolean'
+  | 'date'
+  | 'enum'
+  | 'array'
+  | 'object'
+  | 'reference'
+  | 'unknown'
 
 /** Symbol used to tag reference schema objects. */
-const REFERENCE_TAG = Symbol.for("pyreon:feature:reference")
+const REFERENCE_TAG = Symbol.for('pyreon:feature:reference')
 
 /**
  * Metadata carried by a reference schema.
@@ -61,7 +61,7 @@ export interface ReferenceSchema {
 export function isReference(value: unknown): value is ReferenceSchema {
   return (
     value !== null &&
-    typeof value === "object" &&
+    typeof value === 'object' &&
     (value as Record<symbol, unknown>)[REFERENCE_TAG] === true
   )
 }
@@ -93,7 +93,7 @@ export function reference(feature: { name: string }): ReferenceSchema {
     success: boolean
     error?: { issues: { message: string }[] }
   } {
-    if (typeof value === "string" || typeof value === "number") {
+    if (typeof value === 'string' || typeof value === 'number') {
       return { success: true }
     }
     return {
@@ -113,7 +113,7 @@ export function reference(feature: { name: string }): ReferenceSchema {
     _featureName: featureName,
     safeParse: validateRef,
     safeParseAsync: async (value: unknown) => validateRef(value),
-    _def: { typeName: "ZodString" },
+    _def: { typeName: 'ZodString' },
   }
 }
 
@@ -123,8 +123,8 @@ export function reference(feature: { name: string }): ReferenceSchema {
  */
 function nameToLabel(name: string): string {
   return name
-    .replace(/([a-z])([A-Z])/g, "$1 $2") // camelCase → camel Case
-    .replace(/[_-]/g, " ") // snake_case/kebab-case → spaces
+    .replace(/([a-z])([A-Z])/g, '$1 $2') // camelCase → camel Case
+    .replace(/[_-]/g, ' ') // snake_case/kebab-case → spaces
     .replace(/\b\w/g, (c) => c.toUpperCase()) // capitalize words
 }
 
@@ -141,14 +141,14 @@ function detectFieldType(zodField: unknown): {
   // Check for reference fields first
   if (isReference(zodField)) {
     return {
-      type: "reference",
+      type: 'reference',
       optional: false,
       referenceTo: zodField._featureName,
     }
   }
 
-  if (!zodField || typeof zodField !== "object") {
-    return { type: "unknown", optional: false }
+  if (!zodField || typeof zodField !== 'object') {
+    return { type: 'unknown', optional: false }
   }
 
   const field = zodField as Record<string, unknown>
@@ -161,13 +161,13 @@ function detectFieldType(zodField: unknown): {
   const getTypeName = (obj: Record<string, unknown>): string | undefined => {
     // v3 path
     const def = obj._def as Record<string, unknown> | undefined
-    if (def?.typeName && typeof def.typeName === "string") {
+    if (def?.typeName && typeof def.typeName === 'string') {
       return def.typeName
     }
     // v4 path
     const zod = obj._zod as Record<string, unknown> | undefined
     const zodDef = zod?.def as Record<string, unknown> | undefined
-    if (zodDef?.type && typeof zodDef.type === "string") {
+    if (zodDef?.type && typeof zodDef.type === 'string') {
       return zodDef.type
     }
     return undefined
@@ -177,15 +177,15 @@ function detectFieldType(zodField: unknown): {
 
   // Unwrap optional/nullable
   if (
-    typeName === "ZodOptional" ||
-    typeName === "ZodNullable" ||
-    typeName === "optional" ||
-    typeName === "nullable"
+    typeName === 'ZodOptional' ||
+    typeName === 'ZodNullable' ||
+    typeName === 'optional' ||
+    typeName === 'nullable'
   ) {
     optional = true
     const def = inner._def as Record<string, unknown> | undefined
     const innerType = def?.innerType ?? (inner._zod as Record<string, unknown>)?.def
-    if (innerType && typeof innerType === "object") {
+    if (innerType && typeof innerType === 'object') {
       inner = innerType as Record<string, unknown>
     }
   }
@@ -193,32 +193,32 @@ function detectFieldType(zodField: unknown): {
   const innerTypeName = getTypeName(inner) ?? typeName
 
   // Map Zod type names to our FieldType
-  if (!innerTypeName) return { type: "unknown", optional }
+  if (!innerTypeName) return { type: 'unknown', optional }
 
   const typeMap: Record<string, FieldType> = {
-    ZodString: "string",
-    ZodNumber: "number",
-    ZodBoolean: "boolean",
-    ZodDate: "date",
-    ZodEnum: "enum",
-    ZodNativeEnum: "enum",
-    ZodArray: "array",
-    ZodObject: "object",
+    ZodString: 'string',
+    ZodNumber: 'number',
+    ZodBoolean: 'boolean',
+    ZodDate: 'date',
+    ZodEnum: 'enum',
+    ZodNativeEnum: 'enum',
+    ZodArray: 'array',
+    ZodObject: 'object',
     // v4 names
-    string: "string",
-    number: "number",
-    boolean: "boolean",
-    date: "date",
-    enum: "enum",
-    array: "array",
-    object: "object",
+    string: 'string',
+    number: 'number',
+    boolean: 'boolean',
+    date: 'date',
+    enum: 'enum',
+    array: 'array',
+    object: 'object',
   }
 
-  const type = typeMap[innerTypeName] ?? "string"
+  const type = typeMap[innerTypeName] ?? 'string'
 
   // Extract enum values
   let enumValues: (string | number)[] | undefined
-  if (type === "enum") {
+  if (type === 'enum') {
     const def = inner._def as Record<string, unknown> | undefined
     if (def?.values && Array.isArray(def.values)) {
       enumValues = def.values as (string | number)[]
@@ -254,7 +254,7 @@ function detectFieldType(zodField: unknown): {
  * ```
  */
 export function extractFields(schema: unknown): FieldInfo[] {
-  if (!schema || typeof schema !== "object") return []
+  if (!schema || typeof schema !== 'object') return []
 
   const s = schema as Record<string, unknown>
 
@@ -264,7 +264,7 @@ export function extractFields(schema: unknown): FieldInfo[] {
   let shape: Record<string, unknown> | undefined
 
   // Try schema.shape (works for both v3 and v4)
-  if (s.shape && typeof s.shape === "object") {
+  if (s.shape && typeof s.shape === 'object') {
     shape = s.shape as Record<string, unknown>
   }
 
@@ -273,7 +273,7 @@ export function extractFields(schema: unknown): FieldInfo[] {
     const def = s._def as Record<string, unknown> | undefined
     if (def?.shape) {
       shape =
-        typeof def.shape === "function"
+        typeof def.shape === 'function'
           ? (def.shape as () => Record<string, unknown>)()
           : (def.shape as Record<string, unknown>)
     }
@@ -283,7 +283,7 @@ export function extractFields(schema: unknown): FieldInfo[] {
   if (!shape) {
     const zod = s._zod as Record<string, unknown> | undefined
     const zodDef = zod?.def as Record<string, unknown> | undefined
-    if (zodDef?.shape && typeof zodDef.shape === "object") {
+    if (zodDef?.shape && typeof zodDef.shape === 'object') {
       shape = zodDef.shape as Record<string, unknown>
     }
   }
@@ -311,23 +311,23 @@ export function defaultInitialValues(fields: FieldInfo[]): Record<string, unknow
   const values: Record<string, unknown> = {}
   for (const field of fields) {
     switch (field.type) {
-      case "string":
-        values[field.name] = ""
+      case 'string':
+        values[field.name] = ''
         break
-      case "number":
+      case 'number':
         values[field.name] = 0
         break
-      case "boolean":
+      case 'boolean':
         values[field.name] = false
         break
-      case "enum":
-        values[field.name] = field.enumValues?.[0] ?? ""
+      case 'enum':
+        values[field.name] = field.enumValues?.[0] ?? ''
         break
-      case "date":
-        values[field.name] = ""
+      case 'date':
+        values[field.name] = ''
         break
       default:
-        values[field.name] = ""
+        values[field.name] = ''
     }
   }
   return values