acrylblends 0.8.1 → 0.9.0

package/plugins/acryl-kv-db/src/open.ts

@@ -8,10 +8,10 @@
  * code point in the end, whatever collation the database sorts with.
  */
 
-import type { Db } from '../../acryl-db/src/index.ts'
-import { checkKey, codePoints, compareKeys, decodeValue, encodeValue, type Kv, runChange } from '../../acryl-kv/src/index.ts'
+import type { Db } from 'acryl-db'
+import { checkKey, codePoints, compareKeys, decodeValue, encodeValue, type Kv, runChange } from 'acryl-kv'
 
-export type { Kv } from '../../acryl-kv/src/index.ts'
+export type { Kv } from 'acryl-kv'
 
 export interface KvOnDbOptions {
   /** The table that holds the documents. Defaults to `kv`; a plain SQL identifier. */

package/plugins/acryl-kv-json/plugin.json

@@ -12,5 +12,9 @@
   "omit": ["**/*.test.*", "**/*.spec.*", "**/*.case.ts"],
   "imports": {
     "#acryl-kv-json": "acryl-kv-json/src/index.ts"
+  },
+  "entries": {
+    "": "src/index.ts",
+    "/open": "src/open.ts"
   }
 }

package/plugins/acryl-kv-json/src/index.ts

@@ -10,7 +10,7 @@ import { dirname, isAbsolute, join, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import type { Context } from '@deepseek-ai/cordis'
 import z from '@deepseek-ai/schemastery'
-import { KV_SERVICE } from '../../acryl-kv/src/index.ts'
+import { KV_SERVICE } from 'acryl-kv'
 import { openKv } from './open.ts'
 
 export { openKv, type OpenKvOptions } from './open.ts'

package/plugins/acryl-kv-json/src/open.ts

@@ -13,9 +13,9 @@
 
 import { mkdir, open, readdir, readFile, rename, rm } from 'node:fs/promises'
 import { basename, dirname, join, resolve } from 'node:path'
-import { checkKey, compareKeys, decodeValue, encodeValue, type Kv, type KvOpened, runChange } from '../../acryl-kv/src/index.ts'
+import { checkKey, compareKeys, decodeValue, encodeValue, type Kv, type KvOpened, runChange } from 'acryl-kv'
 
-export type { Kv, KvOpened } from '../../acryl-kv/src/index.ts'
+export type { Kv, KvOpened } from 'acryl-kv'
 
 export interface OpenKvOptions {
   /** The JSON file; its folder is created if missing. */

package/plugins/acryl-node-server/plugin.json

@@ -9,5 +9,9 @@
     "@deepseek-ai/schemastery": "3.18.4"
   },
   "mount": "root.plugin(router); root.plugin(nodeServer, { port: 3000, hostname: '127.0.0.1', scan: 20 }); ctx.nodeServer.url",
-  "omit": ["**/*.test.*", "**/*.case.ts"]
+  "omit": ["**/*.test.*", "**/*.case.ts"],
+  "entries": {
+    "": "src/index.ts",
+    "/client-modules": "src/client-modules.ts"
+  }
 }

package/plugins/acryl-node-server/src/adapter/conninfo.ts

@@ -1,4 +1,4 @@
-import type { GetConnInfo } from '../../../acryl-router/src/helpers/index.ts'
+import type { GetConnInfo } from 'acryl-router/helpers'
 import type { HttpBindings } from './types.ts'
 
 /**

package/plugins/acryl-node-server/src/adapter/early-hints.ts

@@ -1,4 +1,4 @@
-import type { Context, Env, MiddlewareHandler } from '../../../acryl-router/src/index.ts'
+import type { Context, Env, MiddlewareHandler } from 'acryl-router'
 import type { HttpBindings } from './types.ts'
 
 export type EarlyHintsOptions<E extends Env = Env> = {

package/plugins/acryl-node-server/src/adapter/serve-static.ts

@@ -1,5 +1,5 @@
-import type { Context, Env, MiddlewareHandler } from '../../../acryl-router/src/index.ts'
-import { getMimeType } from '../../../acryl-router/src/helpers/index.ts'
+import type { Context, Env, MiddlewareHandler } from 'acryl-router'
+import { getMimeType } from 'acryl-router/helpers'
 import type { Stats } from 'node:fs'
 import { createReadStream, statSync, existsSync } from 'node:fs'
 import { join } from 'node:path'

package/plugins/acryl-node-server/src/adapter/websocket.ts

@@ -1,5 +1,5 @@
-import type { UpgradeWebSocket, WSContext } from '../../../acryl-router/src/helpers/index.ts'
-import { defineWebSocketHelper } from '../../../acryl-router/src/helpers/index.ts'
+import type { UpgradeWebSocket, WSContext } from 'acryl-router/helpers'
+import { defineWebSocketHelper } from 'acryl-router/helpers'
 import type { IncomingMessage } from 'node:http'
 import { STATUS_CODES } from 'node:http'
 import type { Duplex } from 'node:stream'

package/plugins/acryl-node-server/src/client-modules.ts

@@ -12,8 +12,8 @@
 import { copyFileSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from 'node:fs'
 import { dirname, extname, isAbsolute, join, relative, resolve, sep } from 'node:path'
 import { fileURLToPath } from 'node:url'
-import { Acryl } from '../../acryl-router/src/index.ts'
-import { basePath } from '../../acryl-router/src/helpers/index.ts'
+import { Acryl } from 'acryl-router'
+import { basePath } from 'acryl-router/helpers'
 import { MissingTypeScriptError, compileModule } from './transpile.ts'
 
 /** The folder the three browser files are served from, below the app's mount. A source folder of this name is not served. */

package/plugins/acryl-node-server/src/index.ts

@@ -14,7 +14,7 @@ import type { Server } from 'node:http'
 import type { AddressInfo } from 'node:net'
 import { Context, Service } from '@deepseek-ai/cordis'
 import z from '@deepseek-ai/schemastery'
-import type {} from '../../acryl-router/src/index.ts'
+import type {} from 'acryl-router'
 import { Request as AdapterRequest } from './adapter/request.ts'
 import { createAdaptorServer } from './adapter/server.ts'
 

package/plugins/acryl-router/plugin.json

@@ -9,5 +9,15 @@
     "@deepseek-ai/schemastery": "3.18.4"
   },
   "mount": "root.plugin(router); then in your own plugin: inject: ['router'] and ctx.router.get('/path', (c) => c.json({ ok: true }))",
-  "omit": ["**/*.test.*", "**/*.case.ts"]
+  "omit": ["**/*.test.*", "**/*.case.ts"],
+  "entries": {
+    "": "src/index.ts",
+    "/middleware": "src/middleware/index.ts",
+    "/helpers": "src/helpers/index.ts",
+    "/client": "src/client.ts",
+    "/jsx": "src/core/jsx/index.ts",
+    "/jsx/jsx-runtime": "src/core/jsx/jsx-runtime.ts",
+    "/jsx/jsx-dev-runtime": "src/core/jsx/jsx-dev-runtime.ts",
+    "/jsx/streaming": "src/core/jsx/streaming.ts"
+  }
 }

package/plugins/acryl-router/src/connection.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Transport facts: who is on the other end of the socket and which local port it reached. The caller of `router.fetch` supplies them
+ * (an HTTP adapter passes the socket's peer address and real port); they travel in `c.env.connection`, beside the request and never in a header.
+ */
+import type { Context } from './core/context.ts';
+import type { GetConnInfo } from './core/helper/conninfo/types.ts';
+/** An in-process caller (the terminal UI, a test) passes nothing, so a handler that needs a trusted peer must refuse an empty one. */
+export interface ConnectionInfo {
+    /** The peer address of the socket, when the request came over one (for example `127.0.0.1`). */
+    readonly remoteAddress?: string | undefined;
+    /** The local port the socket is connected to, the real one a `Host` header should be checked against. */
+    readonly localPort?: number | undefined;
+}
+/** What the router puts in `c.env`. */
+export interface RouterBindings {
+    readonly connection: ConnectionInfo;
+}
+/** The `Env` of an `Acryl` that wants `c.env.connection` typed: `new Acryl<RouterEnv>()`. */
+export interface RouterEnv {
+    Bindings: RouterBindings;
+}
+/** The transport facts of this request; empty for an in-process call or an `Acryl` run outside the router. */
+export declare function connectionOf(c: Context): ConnectionInfo;
+/** The peer in the core's conninfo shape, for middleware written against it (for example `ipRestriction`). */
+export declare const getConnInfo: GetConnInfo;

package/plugins/acryl-router/src/core/app-base.d.ts

@@ -0,0 +1,215 @@
+/**
+ * @module
+ * This module is the base module for the Acryl object.
+ */
+import { Context } from './context.ts';
+import type { ExecutionContext } from './context.ts';
+import type { Router } from './router.ts';
+import type { Env, ErrorHandler, H, HandlerInterface, MergePath, MergeSchemaPath, MiddlewareHandlerInterface, NotFoundHandler, OnHandlerInterface, RouterRoute, Schema } from './types.ts';
+type GetPath<E extends Env> = (request: Request, options?: {
+    env?: E['Bindings'];
+}) => string;
+export type AcrylOptions<E extends Env> = {
+    /**
+     * `router` option specifies which router to use.
+     *
+     *
+     * @example
+     * ```ts
+     * const app = new Acryl({ router: new RegExpRouter() })
+     * ```
+     */
+    router?: Router<[H, RouterRoute]>;
+} & ({
+    /**
+     * `strict` option specifies whether to distinguish whether the last path is a directory or not.
+     *
+     *
+     * @default true
+     */
+    strict?: true;
+    /**
+     * `getPath` can handle the host header value.
+     *
+     *
+     * @example
+     * ```ts
+     * const app = new Acryl({
+     *  getPath: (req) =>
+     *   '/' + req.headers.get('host') + req.url.replace(/^https?:\/\/[^/]+(\/[^?]*)/, '$1'),
+     * })
+     *
+     * app.get('/www1.example.com/hello', () => c.text('hello www1'))
+     *
+     * // A following request will match the route:
+     * // new Request('http://www1.example.com/hello', {
+     * //  headers: { host: 'www1.example.com' },
+     * // })
+     * ```
+     */
+    getPath?: GetPath<E>;
+} | {
+    /**
+     * `strict` option specifies whether to distinguish whether the last path is a directory or not.
+     * When `strict` is `false`, `getPath` is not used.
+     *
+     *
+     * @default true
+     */
+    strict: false;
+    getPath?: never;
+});
+type MountOptionHandler = (c: Context) => unknown;
+type MountReplaceRequest = (originalRequest: Request) => Request;
+type MountOptions = MountOptionHandler | {
+    optionHandler?: MountOptionHandler;
+    replaceRequest?: MountReplaceRequest | false;
+};
+declare class Acryl<E extends Env = Env, S extends Schema = {}, BasePath extends string = '/', CurrentPath extends string = BasePath> {
+    #private;
+    get: HandlerInterface<E, 'get', S, BasePath, CurrentPath>;
+    post: HandlerInterface<E, 'post', S, BasePath, CurrentPath>;
+    put: HandlerInterface<E, 'put', S, BasePath, CurrentPath>;
+    delete: HandlerInterface<E, 'delete', S, BasePath, CurrentPath>;
+    options: HandlerInterface<E, 'options', S, BasePath, CurrentPath>;
+    patch: HandlerInterface<E, 'patch', S, BasePath, CurrentPath>;
+    query: HandlerInterface<E, 'query', S, BasePath, CurrentPath>;
+    all: HandlerInterface<E, 'all', S, BasePath, CurrentPath>;
+    on: OnHandlerInterface<E, S, BasePath>;
+    use: MiddlewareHandlerInterface<E, S, BasePath>;
+    router: Router<[H, RouterRoute]>;
+    readonly getPath: GetPath<E>;
+    private _basePath;
+    routes: RouterRoute[];
+    constructor(options?: AcrylOptions<E>);
+    private errorHandler;
+    /**
+     * `.route()` allows grouping other Acryl instance in routes.
+     *
+     *
+     * @param {string} path - base Path
+     * @param {Acryl} app - other Acryl instance
+     * @returns {Acryl} routed Acryl instance
+     *
+     * @example
+     * ```ts
+     * const app = new Acryl()
+     * const app2 = new Acryl()
+     *
+     * app2.get("/user", (c) => c.text("user"))
+     * app.route("/api", app2) // GET /api/user
+     * ```
+     */
+    route<SubPath extends string, SubEnv extends Env, SubSchema extends Schema, SubBasePath extends string, SubCurrentPath extends string>(path: SubPath, app: Acryl<SubEnv, SubSchema, SubBasePath, SubCurrentPath>): Acryl<E, MergeSchemaPath<SubSchema, MergePath<BasePath, SubPath>> | S, BasePath, CurrentPath>;
+    /**
+     * `.basePath()` allows base paths to be specified.
+     *
+     *
+     * @param {string} path - base Path
+     * @returns {Acryl} changed Acryl instance
+     *
+     * @example
+     * ```ts
+     * const api = new Acryl().basePath('/api')
+     * ```
+     */
+    basePath<SubPath extends string>(path: SubPath): Acryl<E, S, MergePath<BasePath, SubPath>, MergePath<BasePath, SubPath>>;
+    /**
+     * `.onError()` handles an error and returns a customized Response.
+     *
+     *
+     * @param {ErrorHandler} handler - request Handler for error
+     * @returns {Acryl} changed Acryl instance
+     *
+     * @example
+     * ```ts
+     * app.onError((err, c) => {
+     *   console.error(`${err}`)
+     *   return c.text('Custom Error Message', 500)
+     * })
+     * ```
+     */
+    onError: (handler: ErrorHandler<E>) => Acryl<E, S, BasePath, CurrentPath>;
+    /**
+     * `.notFound()` allows you to customize a Not Found Response.
+     *
+     *
+     * @param {NotFoundHandler} handler - request handler for not-found
+     * @returns {Acryl} changed Acryl instance
+     *
+     * @example
+     * ```ts
+     * app.notFound((c) => {
+     *   return c.text('Custom 404 Message', 404)
+     * })
+     * ```
+     */
+    notFound: (handler: NotFoundHandler<E>) => Acryl<E, S, BasePath, CurrentPath>;
+    /**
+     * `.mount()` allows you to mount applications built with other frameworks into your Acryl application.
+     *
+     * @deprecated Use `mount()` from `acryl-router/mount` instead. `.mount()` will be removed in v5.
+     *
+     *
+     * @param {string} path - base Path
+     * @param {Function} applicationHandler - other Request Handler
+     * @param {MountOptions} [options] - options of `.mount()`
+     * @returns {Acryl} mounted Acryl instance
+     *
+     * @example
+     * ```ts
+     * import { Router as IttyRouter } from 'itty-router'
+     * import { Acryl } from 'acrylblends'
+     * // Create itty-router application
+     * const ittyRouter = IttyRouter()
+     * // GET /itty-router/hello
+     * ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
+     *
+     * const app = new Acryl()
+     * app.mount('/itty-router', ittyRouter.handle)
+     * ```
+     *
+     * @example
+     * ```ts
+     * const app = new Acryl()
+     * // Send the request to another application without modification.
+     * app.mount('/app', anotherApp, {
+     *   replaceRequest: (req) => req,
+     * })
+     * ```
+     */
+    mount(path: string, applicationHandler: (request: Request, ...args: any) => Response | Promise<Response>, options?: MountOptions): Acryl<E, S, BasePath, CurrentPath>;
+    /**
+     * `.fetch()` will be entry point of your app.
+     *
+     *
+     * @param {Request} request - request Object of request
+     * @param {Env} env - env Object
+     * @param {ExecutionContext} executionCtx - context of execution
+     * @returns {Response | Promise<Response>} response of request
+     *
+     */
+    fetch: (request: Request, env?: E['Bindings'] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
+    /**
+     * `.request()` is a useful method for testing.
+     * You can pass a URL or pathname to send a GET request.
+     * app will return a Response object.
+     * ```ts
+     * test('GET /hello is ok', async () => {
+     *   const res = await app.request('/hello')
+     *   expect(res.status).toBe(200)
+     * })
+     * ```
+     */
+    request: (input: Request | string | URL, requestInit?: RequestInit, Env?: E["Bindings"] | {}, executionCtx?: ExecutionContext) => Response | Promise<Response>;
+    /**
+     * `.fire()` automatically adds a global fetch event listener.
+     * This can be useful for environments that adhere to the Service Worker API, such as non-ES module Cloudflare Workers.
+     * @deprecated
+     * ACRYL ships no service-worker adapter: mount the app with `ctx.router.route(path, app)` and serve it through an ACRYL adapter instead.
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API
+     * @see https://developers.cloudflare.com/workers/reference/migrate-to-module-workers/
+     */
+    fire: () => void;
+}
+export { Acryl as AcrylBase };

package/plugins/acryl-router/src/core/app.d.ts

@@ -0,0 +1,19 @@
+import { AcrylBase } from './app-base.ts';
+import type { AcrylOptions } from './app-base.ts';
+import type { BlankEnv, BlankSchema, Env, Schema } from './types.ts';
+/**
+ * The Acryl class extends the functionality of the AcrylBase class.
+ * It sets up routing and allows for custom options to be passed.
+ *
+ * @template E - The environment type.
+ * @template S - The schema type.
+ * @template BasePath - The base path type.
+ */
+export declare class Acryl<E extends Env = BlankEnv, S extends Schema = BlankSchema, BasePath extends string = '/'> extends AcrylBase<E, S, BasePath> {
+    /**
+     * Creates an instance of the Acryl class.
+     *
+     * @param options - Optional configuration options for the Acryl instance.
+     */
+    constructor(options?: AcrylOptions<E>);
+}

package/plugins/acryl-router/src/core/client/client.d.ts

@@ -0,0 +1,4 @@
+import type { Acryl } from '../app.ts';
+import type { UnionToIntersection } from '../utils/types.ts';
+import type { Client, ClientRequestOptions } from './types.ts';
+export declare const hc: <T extends Acryl<any, any, any>, Prefix extends string = string>(baseUrl: Prefix, options?: ClientRequestOptions) => UnionToIntersection<Client<T, Prefix>>;

package/plugins/acryl-router/src/core/client/fetch-result-please.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @description This file is a modified version of `fetch-result-please` (`ofetch`), minimalized and adapted to Acryl's custom needs.
+ *
+ * @link https://www.npmjs.com/package/fetch-result-please
+ */
+/**
+ * Smartly parses and return the consumable result from a fetch `Response`.
+ *
+ * Throwing a structured error if the response is not `ok`. ({@link DetailedError})
+ */
+export declare function fetchRP(fetchRes: Response | Promise<Response>): Promise<any>;
+export declare class DetailedError extends Error {
+    /**
+     * Additional `message` that will be logged AND returned to client
+     */
+    detail?: any;
+    /**
+     * Additional `code` that will be logged AND returned to client
+     */
+    code?: any;
+    /**
+     * Additional value that will be logged AND NOT returned to client
+     */
+    log?: any;
+    /**
+     * Optionally set the status code to return, in a web server context
+     */
+    statusCode?: any;
+    constructor(message: string, options?: {
+        detail?: any;
+        code?: any;
+        statusCode?: number;
+        log?: any;
+    });
+}

package/plugins/acryl-router/src/core/client/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @module
+ * The HTTP Client for Acryl.
+ */
+export { hc } from './client.ts';
+export { parseResponse, DetailedError } from './utils.ts';
+export type { InferResponseType, InferRequestType, Fetch, ClientRequestOptions, ClientRequest, ClientResponse, ApplyGlobalResponse, PickResponseByStatusCode, } from './types.ts';