@holo-js/adapter-next 0.1.3 → 0.1.5

package/dist/client.d.ts

@@ -1,7 +1,7 @@
-import { InferSchemaData } from '@holo-js/forms';
-import { useForm as useForm$1, UseFormOptions, UseFormResult } from '@holo-js/forms/client';
-export { ClientSubmitContext, ClientSubmitResult, FormFieldState, FormFieldTree, UseFormOptions, UseFormResult, ValidateOnMode } from '@holo-js/forms/client';
+import { FormSchema, InferFormData } from '@holo-js/forms';
+import { UseFormOptions, UseFormResult, InferFormFieldTree } from '@holo-js/forms/internal/client';
+export { ClientSubmitContext, ClientSubmitResult, FormFieldState, FormFieldTree, UseFormOptions, UseFormResult, ValidateOnMode } from '@holo-js/forms/internal/client';
 
-declare function useForm<TSchema extends Parameters<typeof useForm$1>[0]>(schemaDefinition: TSchema, options?: UseFormOptions<InferSchemaData<TSchema['fields']>>): UseFormResult<InferSchemaData<TSchema['fields']>>;
+declare function useForm<TSchema extends FormSchema, TSuccess = unknown>(schemaDefinition: TSchema, options?: UseFormOptions<InferFormData<TSchema>, TSuccess>): UseFormResult<InferFormData<TSchema>, TSuccess, InferFormFieldTree<TSchema>>;
 
 export { useForm };

package/dist/client.mjs

@@ -1,8 +1,10 @@
+"use client";
+
 // src/client.ts
 import { useEffect, useRef, useState } from "react";
 import {
-  useForm as createForm
-} from "@holo-js/forms/client";
+  createFormClient
+} from "@holo-js/forms/internal/client";
 function isPlainObject(value) {
   return !!value && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof Blob);
 }
@@ -27,7 +29,7 @@ function areEqual(left, right) {
   return false;
 }
 function areOptionsEqual(left, right) {
-  return left.action === right.action && left.method === right.method && left.csrf === right.csrf && left.validateOn === right.validateOn && Boolean(left.submitter) === Boolean(right.submitter) && areEqual(left.initialValues, right.initialValues) && areEqual(left.initialState, right.initialState);
+  return left.action === right.action && left.method === right.method && left.validateOn === right.validateOn && Boolean(left.submitter) === Boolean(right.submitter) && areEqual(left.initialValues, right.initialValues) && areEqual(left.initialState, right.initialState);
 }
 function createSubmitterBridge(optionsRef) {
   return (context) => {
@@ -39,11 +41,11 @@ function createSubmitterBridge(optionsRef) {
   };
 }
 function useForm(schemaDefinition, options = {}) {
-  const formRef = useRef();
-  const previousSchemaRef = useRef();
-  const previousOptionsRef = useRef();
-  const latestOptionsRef = useRef();
-  const submitterBridgeRef = useRef();
+  const formRef = useRef(void 0);
+  const previousSchemaRef = useRef(void 0);
+  const previousOptionsRef = useRef(void 0);
+  const latestOptionsRef = useRef(void 0);
+  const submitterBridgeRef = useRef(void 0);
   const [, setVersion] = useState(0);
   latestOptionsRef.current = options;
   if (options.submitter && !submitterBridgeRef.current) {
@@ -54,13 +56,13 @@ function useForm(schemaDefinition, options = {}) {
     submitter: submitterBridgeRef.current
   } : options;
   if (!formRef.current || previousSchemaRef.current !== schemaDefinition) {
-    formRef.current = createForm(schemaDefinition, resolvedOptions);
+    formRef.current = createFormClient(schemaDefinition, resolvedOptions);
     previousSchemaRef.current = schemaDefinition;
     previousOptionsRef.current = options;
   } else {
     const previousOptions = previousOptionsRef.current;
     if (!areOptionsEqual(previousOptions, options)) {
-      formRef.current = createForm(schemaDefinition, resolvedOptions);
+      formRef.current = createFormClient(schemaDefinition, resolvedOptions);
       previousOptionsRef.current = options;
     }
   }

package/dist/config.d.ts

@@ -0,0 +1,19 @@
+interface TurbopackIgnoreIssueRule {
+    readonly path: string | RegExp;
+    readonly title?: string | RegExp;
+}
+interface TurbopackConfig {
+    readonly ignoreIssue?: readonly TurbopackIgnoreIssueRule[];
+    readonly [key: string]: unknown;
+}
+interface NextConfig {
+    readonly serverExternalPackages?: string[];
+    readonly outputFileTracingExcludes?: Record<string, string[]>;
+    readonly experimental?: Record<string, unknown>;
+    readonly turbopack?: TurbopackConfig;
+    readonly rewrites?: () => Promise<unknown>;
+    readonly [key: string]: unknown;
+}
+declare function withHolo<TConfig extends NextConfig>(nextConfig?: TConfig): TConfig;
+
+export { withHolo };

package/dist/config.mjs

@@ -0,0 +1,133 @@
+// src/config.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+var HOLO_SERVER_EXTERNAL_PACKAGES = [
+  "@holo-js/core",
+  "@holo-js/adapter-next",
+  "@holo-js/db",
+  "@holo-js/config",
+  "esbuild"
+];
+var HOLO_OPTIONAL_SERVER_EXTERNAL_PACKAGES = [
+  "@holo-js/auth",
+  "@holo-js/auth-clerk",
+  "@holo-js/auth-social",
+  "@holo-js/auth-social-apple",
+  "@holo-js/auth-social-discord",
+  "@holo-js/auth-social-facebook",
+  "@holo-js/auth-social-github",
+  "@holo-js/auth-social-google",
+  "@holo-js/auth-social-linkedin",
+  "@holo-js/auth-workos",
+  "@holo-js/authorization",
+  "@holo-js/broadcast",
+  "@holo-js/cache",
+  "@holo-js/cache-db",
+  "@holo-js/cache-redis",
+  "@holo-js/events",
+  "@holo-js/forms",
+  "@holo-js/mail",
+  "@holo-js/notifications",
+  "@holo-js/queue",
+  "@holo-js/queue-db",
+  "@holo-js/queue-redis",
+  "@holo-js/security",
+  "@holo-js/session",
+  "@holo-js/storage",
+  "@holo-js/storage-s3",
+  "@holo-js/validation"
+];
+var PACKAGE_DEPENDENCY_FIELDS = [
+  "dependencies",
+  "devDependencies",
+  "optionalDependencies",
+  "peerDependencies"
+];
+function isPackageDependencyMap(value) {
+  return value !== null && typeof value === "object" && Object.values(value).every((dependency) => typeof dependency === "string");
+}
+function readProjectPackageManifest() {
+  try {
+    const parsed = JSON.parse(readFileSync(join(process.cwd(), "package.json"), "utf8"));
+    if (!parsed || typeof parsed !== "object") {
+      return null;
+    }
+    const manifest = {};
+    for (const field of PACKAGE_DEPENDENCY_FIELDS) {
+      const dependencies = parsed[field];
+      if (isPackageDependencyMap(dependencies)) {
+        manifest[field] = dependencies;
+      }
+    }
+    return manifest;
+  } catch {
+    return null;
+  }
+}
+function isOptionalServerExternalPackageInstalled(packageName, manifest) {
+  return PACKAGE_DEPENDENCY_FIELDS.some((field) => Boolean(manifest?.[field]?.[packageName]));
+}
+function withHolo(nextConfig = {}) {
+  const existingExternal = nextConfig.serverExternalPackages ?? [];
+  const packageManifest = readProjectPackageManifest();
+  const installedOptionalExternal = HOLO_OPTIONAL_SERVER_EXTERNAL_PACKAGES.filter((packageName) => isOptionalServerExternalPackageInstalled(packageName, packageManifest));
+  const mergedExternal = [
+    .../* @__PURE__ */ new Set([...HOLO_SERVER_EXTERNAL_PACKAGES, ...installedOptionalExternal, ...existingExternal])
+  ];
+  const existingExcludes = nextConfig.outputFileTracingExcludes ?? {};
+  const existingGlobalExcludes = existingExcludes["/*"] ?? [];
+  const mergedExcludes = {
+    ...existingExcludes,
+    "/*": [.../* @__PURE__ */ new Set(["./next.config.ts", "./next.config.mjs", "./next.config.js", ...existingGlobalExcludes])]
+  };
+  const existingTurbopack = nextConfig.turbopack ?? {};
+  const existingIgnoreIssue = existingTurbopack.ignoreIssue ?? [];
+  const mergedTurbopack = {
+    ...existingTurbopack,
+    ignoreIssue: [
+      ...existingIgnoreIssue,
+      {
+        path: /next\.config\.(ts|mjs|js)$/,
+        title: /Encountered unexpected file in NFT list/
+      }
+    ]
+  };
+  const userRewrites = nextConfig.rewrites;
+  return {
+    ...nextConfig,
+    experimental: {
+      ...nextConfig.experimental ?? {},
+      authInterrupts: true
+    },
+    serverExternalPackages: mergedExternal,
+    outputFileTracingExcludes: mergedExcludes,
+    turbopack: mergedTurbopack,
+    async rewrites() {
+      const userResult = await userRewrites?.call(this);
+      const raw = process.env.STORAGE_ROUTE_PREFIX?.trim() ?? "/storage";
+      const needsRewrite = raw && raw !== "/" && raw !== "/storage";
+      if (!needsRewrite) {
+        return userResult ?? [];
+      }
+      const storageRoutePrefix = `/${raw.replace(/^\/+|\/+$/g, "")}`;
+      const holoRewrite = {
+        source: `${storageRoutePrefix}/:path*`,
+        destination: "/storage/:path*"
+      };
+      if (Array.isArray(userResult)) {
+        return [...userResult, holoRewrite];
+      }
+      if (userResult && typeof userResult === "object" && !Array.isArray(userResult)) {
+        const shaped = userResult;
+        return {
+          ...shaped,
+          beforeFiles: [...Array.isArray(shaped.beforeFiles) ? shaped.beforeFiles : [], holoRewrite]
+        };
+      }
+      return [holoRewrite];
+    }
+  };
+}
+export {
+  withHolo
+};

package/dist/runtime.d.ts

@@ -0,0 +1,137 @@
+import * as _holo_js_core from '@holo-js/core';
+import { CreateHoloOptions } from '@holo-js/core';
+import { HoloConfigMap, LoadedHoloConfig, DotPath, ValueAtPath } from '@holo-js/config';
+
+interface GeneratedModelRegistryEntry {
+    readonly sourcePath: string;
+    readonly name: string;
+    readonly prunable: boolean;
+}
+interface GeneratedMigrationRegistryEntry {
+    readonly sourcePath: string;
+    readonly name: string;
+}
+interface GeneratedSeederRegistryEntry {
+    readonly sourcePath: string;
+    readonly name: string;
+}
+interface GeneratedCommandRegistryEntry {
+    readonly sourcePath: string;
+    readonly name: string;
+    readonly aliases: readonly string[];
+    readonly description: string;
+    readonly usage?: string;
+}
+interface GeneratedJobRegistryEntry {
+    readonly sourcePath: string;
+    readonly name: string;
+    readonly connection?: string;
+    readonly queue?: string;
+    readonly tries?: number;
+    readonly backoff?: number | readonly number[];
+    readonly timeout?: number;
+}
+interface GeneratedEventRegistryEntry {
+    readonly sourcePath: string;
+    readonly name: string;
+    readonly exportName?: string;
+}
+interface GeneratedListenerRegistryEntry {
+    readonly sourcePath: string;
+    readonly id: string;
+    readonly eventNames: readonly string[];
+    readonly exportName?: string;
+}
+interface GeneratedBroadcastRegistryEntry {
+    readonly sourcePath: string;
+    readonly name: string;
+    readonly exportName?: string;
+    readonly channels: readonly {
+        readonly type: 'public' | 'private' | 'presence';
+        readonly pattern: string;
+    }[];
+}
+interface GeneratedChannelRegistryEntry {
+    readonly sourcePath: string;
+    readonly pattern: string;
+    readonly exportName?: string;
+    readonly type: 'private' | 'presence';
+    readonly params: readonly string[];
+    readonly whispers: readonly string[];
+}
+interface GeneratedAuthorizationPolicyRegistryEntry {
+    readonly sourcePath: string;
+    readonly name: string;
+    readonly exportName?: string;
+    readonly target: string;
+    readonly classActions: readonly string[];
+    readonly recordActions: readonly string[];
+}
+interface GeneratedAuthorizationAbilityRegistryEntry {
+    readonly sourcePath: string;
+    readonly name: string;
+    readonly exportName?: string;
+}
+interface GeneratedProjectRegistry {
+    readonly version: 1;
+    readonly generatedAt: string;
+    readonly paths: {
+        readonly models: string;
+        readonly migrations: string;
+        readonly seeders: string;
+        readonly commands: string;
+        readonly jobs: string;
+        readonly events: string;
+        readonly listeners: string;
+        readonly broadcast: string;
+        readonly channels: string;
+        readonly authorizationPolicies: string;
+        readonly authorizationAbilities: string;
+        readonly generatedSchema: string;
+    };
+    readonly models: readonly GeneratedModelRegistryEntry[];
+    readonly migrations: readonly GeneratedMigrationRegistryEntry[];
+    readonly seeders: readonly GeneratedSeederRegistryEntry[];
+    readonly commands: readonly GeneratedCommandRegistryEntry[];
+    readonly jobs: readonly GeneratedJobRegistryEntry[];
+    readonly events: readonly GeneratedEventRegistryEntry[];
+    readonly listeners: readonly GeneratedListenerRegistryEntry[];
+    readonly broadcast: readonly GeneratedBroadcastRegistryEntry[];
+    readonly channels: readonly GeneratedChannelRegistryEntry[];
+    readonly authorizationPolicies: readonly GeneratedAuthorizationPolicyRegistryEntry[];
+    readonly authorizationAbilities: readonly GeneratedAuthorizationAbilityRegistryEntry[];
+}
+
+type NextRequestLike = {
+    readonly cookies: {
+        get(name: string): {
+            readonly value: string;
+        } | undefined;
+    };
+    readonly headers: Headers;
+};
+declare function runWithNextRequest<TValue>(request: NextRequestLike, callback: () => TValue): TValue;
+
+type NextHoloRuntimeOptions = CreateHoloOptions & {
+    readonly projectRoot: string;
+};
+declare function createNextHoloHelpers<TCustom extends HoloConfigMap = HoloConfigMap>(options: NextHoloRuntimeOptions): {
+    getApp(): Promise<{
+        projectRoot: string;
+        config: LoadedHoloConfig<TCustom>;
+        registry: GeneratedProjectRegistry | undefined;
+        runtime: _holo_js_core.HoloRuntime<TCustom>;
+    }>;
+    getProject(): Promise<{
+        projectRoot: string;
+        config: LoadedHoloConfig<TCustom>;
+        registry: GeneratedProjectRegistry | undefined;
+        runtime: _holo_js_core.HoloRuntime<TCustom>;
+    }>;
+    getSession(): Promise<_holo_js_core.HoloSessionRuntimeBinding | undefined>;
+    getAuth(): Promise<_holo_js_core.HoloAuthRuntimeBinding | undefined>;
+    useConfig: <TPath extends DotPath<LoadedHoloConfig<TCustom>["all"]>>(path: TPath) => Promise<ValueAtPath<LoadedHoloConfig<TCustom>["all"], TPath>>;
+    config: <TPath extends DotPath<LoadedHoloConfig<TCustom>["all"]>>(path: TPath) => Promise<ValueAtPath<LoadedHoloConfig<TCustom>["all"], TPath>>;
+};
+
+export { type NextHoloRuntimeOptions, type NextRequestLike, createNextHoloHelpers, runWithNextRequest };

package/dist/runtime.mjs

@@ -0,0 +1,169 @@
+// src/runtime.ts
+import { cookies, headers } from "next/headers";
+import { forbidden, notFound } from "next/navigation";
+import { initializeHolo } from "@holo-js/core";
+
+// src/request-context.ts
+import { AsyncLocalStorage } from "async_hooks";
+function getNextRequestStore() {
+  const globals = globalThis;
+  globals.__holoNextAuthRequestStore ??= new AsyncLocalStorage();
+  return globals.__holoNextAuthRequestStore;
+}
+function getCurrentNextRequest() {
+  return getNextRequestStore().getStore();
+}
+function runWithNextRequest(request, callback) {
+  return getNextRequestStore().run(request, callback);
+}
+
+// src/runtime.ts
+function safeDecodeCookieSegment(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function parseResponseCookie(cookie) {
+  const [nameValue, ...attributes] = cookie.split(";");
+  const separator = nameValue?.indexOf("=") ?? -1;
+  if (!nameValue || separator <= 0) {
+    return null;
+  }
+  const options = {};
+  for (const rawAttribute of attributes) {
+    const attribute = rawAttribute.trim();
+    if (!attribute) {
+      continue;
+    }
+    const attributeSeparator = attribute.indexOf("=");
+    const key = (attributeSeparator === -1 ? attribute : attribute.slice(0, attributeSeparator)).trim().toLowerCase();
+    const value = attributeSeparator === -1 ? "" : attribute.slice(attributeSeparator + 1).trim();
+    switch (key) {
+      case "path":
+        options.path = value;
+        break;
+      case "domain":
+        options.domain = value;
+        break;
+      case "max-age": {
+        const maxAge = Number(value);
+        if (Number.isFinite(maxAge)) {
+          options.maxAge = maxAge;
+        }
+        break;
+      }
+      case "expires": {
+        const expires = new Date(value);
+        if (!Number.isNaN(expires.getTime())) {
+          options.expires = expires;
+        }
+        break;
+      }
+      case "secure":
+        options.secure = true;
+        break;
+      case "httponly":
+        options.httpOnly = true;
+        break;
+      case "samesite":
+        if (value.toLowerCase() === "lax" || value.toLowerCase() === "strict" || value.toLowerCase() === "none") {
+          options.sameSite = value.toLowerCase();
+        }
+        break;
+      case "partitioned":
+        options.partitioned = true;
+        break;
+    }
+  }
+  return {
+    name: safeDecodeCookieSegment(nameValue.slice(0, separator)),
+    value: safeDecodeCookieSegment(nameValue.slice(separator + 1)),
+    options
+  };
+}
+function resolveNextAuthRequestAccessors() {
+  return {
+    async getCookie(name) {
+      const request = getCurrentNextRequest();
+      if (request) {
+        return request.cookies.get(name)?.value;
+      }
+      const store = await cookies();
+      return store.get(name)?.value;
+    },
+    async getHeader(name) {
+      const request = getCurrentNextRequest();
+      if (request) {
+        return request.headers.get(name) ?? void 0;
+      }
+      const requestHeaders = await headers();
+      return requestHeaders.get(name) ?? void 0;
+    },
+    async appendResponseCookie(cookie) {
+      const parsed = parseResponseCookie(cookie);
+      if (!parsed) {
+        return;
+      }
+      const store = await cookies();
+      store.set(parsed.name, parsed.value, parsed.options);
+    },
+    async redirectResponse(url) {
+      const { redirect } = await import("next/navigation");
+      redirect(url);
+    }
+  };
+}
+function createNextHoloHelpers(options) {
+  const resolveRuntime = async () => await initializeHolo(options.projectRoot, {
+    ...options,
+    authRequest: options.authRequest ?? resolveNextAuthRequestAccessors(),
+    authorizationError: options.authorizationError ?? {
+      createError(decision) {
+        if (decision.status === 404) {
+          notFound();
+        }
+        forbidden();
+      }
+    }
+  });
+  const useConfig = async (path) => {
+    const runtime = await resolveRuntime();
+    return runtime.config(path);
+  };
+  return {
+    async getApp() {
+      const runtime = await resolveRuntime();
+      return {
+        projectRoot: runtime.projectRoot,
+        config: runtime.loadedConfig,
+        registry: runtime.registry,
+        runtime
+      };
+    },
+    async getProject() {
+      const runtime = await resolveRuntime();
+      return {
+        projectRoot: runtime.projectRoot,
+        config: runtime.loadedConfig,
+        registry: runtime.registry,
+        runtime
+      };
+    },
+    async getSession() {
+      const runtime = await resolveRuntime();
+      return runtime.session;
+    },
+    async getAuth() {
+      const runtime = await resolveRuntime();
+      return runtime.auth;
+    },
+    useConfig,
+    config: useConfig
+  };
+}
+export {
+  createNextHoloHelpers,
+  runWithNextRequest
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holo-js/adapter-next",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Holo-JS Framework - Next.js adapter",
   "type": "module",
   "license": "MIT",
@@ -10,10 +10,20 @@
       "import": "./dist/index.mjs",
       "default": "./dist/index.mjs"
     },
+    "./config": {
+      "types": "./dist/config.d.ts",
+      "import": "./dist/config.mjs",
+      "default": "./dist/config.mjs"
+    },
     "./client": {
       "types": "./dist/client.d.ts",
       "import": "./dist/client.mjs",
       "default": "./dist/client.mjs"
+    },
+    "./runtime": {
+      "types": "./dist/runtime.d.ts",
+      "import": "./dist/runtime.mjs",
+      "default": "./dist/runtime.mjs"
     }
   },
   "main": "./dist/index.mjs",
@@ -28,11 +38,13 @@
     "test": "vitest --run"
   },
   "dependencies": {
-    "@holo-js/config": "^0.1.3",
-    "@holo-js/core": "^0.1.3"
+    "@holo-js/config": "^0.1.5",
+    "@holo-js/core": "^0.1.5"
   },
   "peerDependencies": {
-    "@holo-js/forms": "^0.1.3"
+    "@holo-js/forms": "^0.1.5",
+    "next": "^16.2.4",
+    "react": "^19.2.6"
   },
   "peerDependenciesMeta": {
     "@holo-js/forms": {
@@ -41,8 +53,9 @@
   },
   "devDependencies": {
     "@types/node": "^22.10.2",
+    "next": "^16.2.4",
     "tsup": "^8.3.5",
     "typescript": "^5.7.2",
-    "vitest": "^2.1.8"
+    "vitest": "^4.1.5"
   }
 }