@stacksjs/api 0.70.22 → 0.70.25

package/dist/src/fetcher.d.ts

@@ -0,0 +1,42 @@
+import type { BodyData, FetcherResponse, QueryParams } from './types';
+export declare const fetcher: Fetcher;
+declare class FetcherResponseImpl<T> implements FetcherResponse<T> {
+  public data: T;
+  public status: number;
+  public headers: Headers;
+  public isOk: boolean;
+  constructor(data: T, status: number, headers: Headers, isOk: boolean);
+  ok(): boolean;
+  created(): boolean;
+  accepted(): boolean;
+  noContent(): boolean;
+  movedPermanently(): boolean;
+  found(): boolean;
+  badRequest(): boolean;
+  unauthorized(): boolean;
+  paymentRequired(): boolean;
+  forbidden(): boolean;
+  notFound(): boolean;
+  requestTimeout(): boolean;
+  conflict(): boolean;
+  unprocessableEntity(): boolean;
+  tooManyRequests(): boolean;
+  serverError(): boolean;
+}
+declare class Fetcher {
+  withQueryParams(params: QueryParams): this;
+  withHeaders(headers: Record<string, string>): this;
+  accept(contentType: string): this;
+  acceptJson(): this;
+  withToken(token: string): this;
+  withBasicAuth(username: string, password: string): this;
+  withDigestAuth(username: string, password: string): this;
+  withBody<D extends BodyData>(data: D): this;
+  asForm(): this;
+  attach(name: string, content: string | Blob | File, filename?: string, headers?: Record<string, string>): this;
+  get<T = string>(url: string): Promise<FetcherResponse<T>>;
+  post<T = string, D extends BodyData = BodyData>(url: string, body?: D): Promise<FetcherResponse<T>>;
+  put<T = string, D extends BodyData = BodyData>(url: string, body?: D): Promise<FetcherResponse<T>>;
+  patch<T = string, D extends BodyData = BodyData>(url: string, body?: D): Promise<FetcherResponse<T>>;
+  delete<T = string>(url: string): Promise<FetcherResponse<T>>;
+}

package/dist/src/generate-openapi.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Build an OpenAPI 3.0 spec from the live route registry.
+ *
+ * The previous shape called `route.routes()` (which doesn't exist —
+ * `routes` is a getter, not a callable) and read fields like
+ * `route.url`, `route.statusCode`, `route.responseSchema` that the
+ * underlying bun-router doesn't actually expose. This rewrite uses
+ * `listRegisteredRoutes()` (the canonical introspection helper) and
+ * derives request schemas from each action's `validations` block when
+ * available.
+ *
+ * Without `Action.validations`, the spec lists the path + parameters
+ * but omits a request body schema — that's still useful for clients
+ * that just want to know what endpoints exist.
+ */
+export declare function generateOpenApi(): Promise<OpenApiSpec>;
+declare interface OpenApiPathItem {
+  [method: string]: {
+    summary?: string
+    operationId?: string
+    parameters?: Array<{ name: string, in: string, required: boolean, schema: { type: string } }>
+    responses: Record<string, { description: string, content?: Record<string, unknown> }>
+    requestBody?: { content: Record<string, unknown>, required?: boolean }
+  }
+}
+declare interface OpenApiSpec {
+  openapi: string
+  info: { title: string, version: string }
+  paths: Record<string, OpenApiPathItem>
+  components: { schemas: Record<string, unknown> }
+}

package/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from './fetcher';
+export * from './generate-openapi';
+export * from './resource';

package/dist/src/resource.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Anonymous Resource
+ *
+ * Create a resource inline without a class.
+ */
+export declare function resource<T>(data: T, transform: (resource: T) => Record<string, any>): { toResponse: () => Record<string, any>, toJson: () => string };
+/**
+ * Anonymous Collection
+ *
+ * Create a collection inline without a class.
+ */
+export declare function collection<T>(data: T[], transform: (resource: T) => Record<string, any>): { toResponse: () => Record<string, any>, toJson: () => string };
+/**
+ * Pagination metadata structure
+ */
+export declare interface PaginationMeta {
+  current_page: number
+  from: number | null
+  last_page: number
+  per_page: number
+  to: number | null
+  total: number
+}
+export declare interface PaginationLinks {
+  first: string | null
+  last: string | null
+  prev: string | null
+  next: string | null
+}
+export declare interface PaginatedData<T> {
+  data: T[]
+  meta: PaginationMeta
+  links: PaginationLinks
+}
+/**
+ * API Resources
+ *
+ * Laravel-like API resources for transforming models and collections
+ * into JSON responses with fine-grained control.
+ *
+ * @example
+ * class UserResource extends JsonResource<User> {
+ *   toArray() {
+ *     return {
+ *       id: this.resource.id,
+ *       name: this.resource.name,
+ *       email: this.resource.email,
+ *       posts: PostResource.collection(this.whenLoaded('posts')),
+ *       created_at: this.resource.created_at,
+ *     }
+ *   }
+ * }
+ *
+ * // Usage
+ * return new UserResource(user).toResponse()
+ * return UserResource.collection(users).toResponse()
+ */
+declare type Request = Record<string, unknown>;
+/**
+ * Wrapper value types for conditional inclusion
+ */
+export declare class MissingValue {
+  static instance: unknown;
+  isMissing(): boolean;
+}
+export declare class MergeValue {
+  public data: Record<string, any>;
+  constructor(data: Record<string, any>);
+}
+export declare class ConditionalValue {
+  public condition: boolean | (() => boolean);
+  public value: any;
+  public defaultValue?: any;
+  constructor(condition: boolean | (() => boolean), value: any, defaultValue?: any);
+  resolve(): any;
+}
+/**
+ * Base JSON Resource class
+ *
+ * Extend this class to create custom API resources that transform
+ * your models into JSON-serializable objects.
+ */
+export declare abstract class JsonResource<T = unknown> {
+  resource: T;
+  additional: Record<string, any>;
+  protected request?: Request;
+  static wrap: string | null;
+  protected static additionalMeta: Record<string, any>;
+  constructor(resource: T);
+  abstract toArray(request?: Request): Record<string, any>;
+  withRequest(request: Request): this;
+  withAdditional(data: Record<string, any>): this;
+  resolve(request?: Request): Record<string, any>;
+  toResponse(request?: Request): Record<string, any>;
+  toJson(request?: Request): string;
+  toJSON(): Record<string, unknown>;
+  static collection<T, R extends JsonResource<T>>(this: new (resource: T) => R, resources: T[]): ResourceCollection<T, R>;
+  protected when<V>(condition: boolean | (() => boolean), value: V | (() => V), defaultValue?: any): V | MissingValue;
+  protected whenNotNull<V>(value: V | null | undefined, transform?: (v: V) => any): any | MissingValue;
+  protected whenLoaded<V>(relationship: string, value?: V | (() => V), defaultValue?: any): V | any[] | MissingValue;
+  protected whenCounted(relationship: string, defaultValue?: number): number | MissingValue;
+  protected merge(data: Record<string, any>): MergeValue;
+  protected mergeWhen(condition: boolean | (() => boolean), data: Record<string, any> | (() => Record<string, any>)): MergeValue | MissingValue;
+  static withoutWrapping(): void;
+  static wrapWith(key: string): void;
+}
+/**
+ * Resource Collection
+ *
+ * Wraps an array of resources with collection-specific functionality.
+ */
+export declare class ResourceCollection<T = unknown, R extends JsonResource<T> = JsonResource<T>> {
+  resources: T[];
+  ResourceClass: new (resource: T) => R;
+  additional: Record<string, any>;
+  protected request?: Request;
+  static wrap: string | null;
+  constructor(resources: T[], ResourceClass: new (resource: T) => R);
+  withRequest(request: Request): this;
+  withAdditional(data: Record<string, any>): this;
+  resolve(request?: Request): Record<string, any>[];
+  toResponse(request?: Request): Record<string, any>;
+  toJson(request?: Request): string;
+  count(): number;
+  isEmpty(): boolean;
+  isNotEmpty(): boolean;
+}
+/**
+ * Paginated Resource Collection
+ *
+ * Handles paginated data with meta and links.
+ */
+export declare class PaginatedResourceCollection<T = unknown, R extends JsonResource<T> = JsonResource<T>> extends ResourceCollection<T, R> {
+  meta: PaginationMeta;
+  links: PaginationLinks;
+  constructor(paginatedData: PaginatedData<T>, ResourceClass: new (resource: T) => R);
+  static fromPagination<T, R extends JsonResource<T>>(data: T[], ResourceClass: new (resource: T) => R, options: {
+      currentPage: number
+      perPage: number
+      total: number
+      baseUrl?: string
+    }): PaginatedResourceCollection<T, R>;
+  toResponse(request?: Request): Record<string, any>;
+}

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "@stacksjs/api",
   "type": "module",
-  "version": "0.70.22",
+  "version": "0.70.25",
   "description": "The Stacks array utilities.",
   "author": "Chris Breuer",
-  "contributors": ["Chris Breuer <chris@stacksjs.org>"],
+  "contributors": [
+    "Chris Breuer <chris@stacksjs.com>"
+  ],
   "license": "MIT",
   "funding": "https://github.com/sponsors/chrisbbreuer",
   "homepage": "https://github.com/stacksjs/stacks/tree/main/storage/framework/core/arrays#readme",
@@ -26,25 +28,29 @@
   ],
   "exports": {
     ".": {
+      "bun": "./src/index.ts",
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
     "./*": {
+      "bun": "./src/*",
       "import": "./dist/*"
     }
   },
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
-  "files": ["README.md", "dist"],
+  "files": [
+    "README.md",
+    "dist"
+  ],
   "scripts": {
     "build": "bun build.ts",
-    "generate-types": "openapi-typescript ./../../api/openapi.json --output ./../../api/api-types.ts",
+    "generate-types": "open-api ./../../api/openapi.json --output ./../../api/api-types.ts",
     "typecheck": "bun tsc --noEmit",
     "prepublishOnly": "bun run build"
   },
   "devDependencies": {
-    "@stacksjs/development": "0.70.18",
-    "@stacksjs/utils": "0.70.18",
-    "ofetch": "^1.4.1",
-    "openapi-typescript": "^7.6.1"
+    "better-dx": "^0.2.12",
+    "@stacksjs/utils": "0.70.23"
   }
 }

package/dist/generate-openapi.d.ts

@@ -1,2 +0,0 @@
-export declare function generateOpenApi(): Promise<void>;
-declare const file: unknown;

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-export * from './generate-openapi'
-export * from './ofetch'

package/dist/ofetch.d.ts

@@ -1,103 +0,0 @@
-declare interface Params {
-  [key: string]: any 
-}
-declare interface ApiFetch {
-  get: (url: string, params?: Params, header?: Headers) => Promise<FetchResponse>
-  post: (url: string, params?: Params, header?: Headers) => Promise<FetchResponse>
-  destroy: (url: string, params?: Params, header?: Headers) => Promise<FetchResponse>
-  patch: (url: string, params?: Params, header?: Headers) => Promise<FetchResponse>
-  put: (url: string, params?: Params, header?: Headers) => Promise<FetchResponse>
-  setToken: (authToken: string) => void
-  baseURL: '/' | string
-  loading: boolean
-  token: string
-}
-declare type FetchResponse = string | Blob | ArrayBuffer | ReadableStream<Uint8Array>
-
-let loading = false
-let token = ''
-const baseURL = '/'
-
-async function get(url: string, params?: Params, headers?: Headers): Promise<FetchResponse> {
-  if (headers) {
-    if (token)
-      headers.set('Authorization', `Bearer ${token}`)
-  }
-
-  return await ofetch(url, { method: 'GET', baseURL, params, headers })
-}
-
-async function post(url: string, params?: Params, headers?: Headers): Promise<any> {
-  if (headers) {
-    if (token)
-      headers.set('Authorization', `Bearer ${token}`)
-  }
-
-  loading = true
-
-  try {
-    const result: string | FetchResponse | Blob | ArrayBuffer | ReadableStream<Uint8Array> = await ofetch(url, {
-      method: 'POST',
-      baseURL,
-      params,
-      headers,
-    })
-
-    loading = false
-    return result
-  }
-  catch (err: any) {
-    loading = false
-
-    throw err
-  }
-}
-
-async function patch(url: string, params?: Params, headers?: Headers): Promise<FetchResponse> {
-  if (headers) {
-    if (token)
-      headers.set('Authorization', `Bearer ${token}`)
-  }
-
-  loading = true
-
-  return await ofetch(url, {
-    method: 'PATCH',
-    baseURL,
-    params,
-    headers,
-  })
-}
-
-async function put(url: string, params?: Params, headers?: Headers): Promise<FetchResponse> {
-  if (headers) {
-    if (token)
-      headers.set('Authorization', `Bearer ${token}`)
-  }
-
-  loading = true
-
-  return await ofetch(url, {
-    method: 'PUT',
-    baseURL,
-    params,
-    headers,
-  })
-}
-
-async function destroy(url: string, params?: Params, headers?: Headers): Promise<FetchResponse> {
-  if (headers) {
-    if (token)
-      headers.set('Authorization', `Bearer ${token}`)
-  }
-
-  loading = true
-
-  return await ofetch(url, {
-    method: 'DELETE',
-    baseURL,
-    params,
-    headers,
-  })
-}
-declare function setToken(authToken: string): void;