@holo-js/adapter-next 0.1.9 → 0.2.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/chunk-3RI2KDLY.mjs +74 -0
- package/dist/client.mjs +22 -4
- package/dist/config.d.ts +13 -0
- package/dist/config.mjs +47 -0
- package/dist/realtime-definition-loader.d.ts +6 -0
- package/dist/realtime-definition-loader.mjs +279 -0
- package/dist/realtime.d.ts +7 -0
- package/dist/realtime.mjs +113 -0
- package/dist/runtime.d.ts +3 -1
- package/dist/runtime.mjs +51 -19
- package/package.json +14 -4
|
@@ -0,0 +1,74 @@
|
|
|
1
|
+
// src/client-errors.ts
|
|
2
|
+
import { normalizeHoloHttpError } from "@holo-js/core/errors";
|
|
3
|
+
var nextHttpAccessFallbackStatuses = /* @__PURE__ */ new Set([401, 403, 404]);
|
|
4
|
+
function normalizeNextClientHttpError(error) {
|
|
5
|
+
return normalizeHoloHttpError(error);
|
|
6
|
+
}
|
|
7
|
+
function createNextRenderableError(error) {
|
|
8
|
+
if (!nextHttpAccessFallbackStatuses.has(error.status)) {
|
|
9
|
+
return new Error(error.message, { cause: error.cause });
|
|
10
|
+
}
|
|
11
|
+
const nextError = new Error(error.message, { cause: error.cause });
|
|
12
|
+
nextError.digest = `NEXT_HTTP_ERROR_FALLBACK;${error.status}`;
|
|
13
|
+
return nextError;
|
|
14
|
+
}
|
|
15
|
+
function renderNextClientHttpErrorPage(error) {
|
|
16
|
+
const browserDocument = globalThis.document;
|
|
17
|
+
if (!browserDocument) {
|
|
18
|
+
return;
|
|
19
|
+
}
|
|
20
|
+
browserDocument.title = `${error.status}: ${error.message}`;
|
|
21
|
+
const existingRoot = browserDocument.getElementById("__holo_next_client_http_error__");
|
|
22
|
+
const root = existingRoot ?? browserDocument.createElement("main");
|
|
23
|
+
root.id = "__holo_next_client_http_error__";
|
|
24
|
+
root.setAttribute("role", "alert");
|
|
25
|
+
root.style.cssText = [
|
|
26
|
+
"position:fixed",
|
|
27
|
+
"inset:0",
|
|
28
|
+
"z-index:2147483647",
|
|
29
|
+
"display:grid",
|
|
30
|
+
"place-items:center",
|
|
31
|
+
"margin:0",
|
|
32
|
+
"background:#fff",
|
|
33
|
+
"color:#000",
|
|
34
|
+
"font-family:Arial,Helvetica,sans-serif"
|
|
35
|
+
].join(";");
|
|
36
|
+
const wrapper = browserDocument.createElement("div");
|
|
37
|
+
wrapper.style.cssText = "display:flex;align-items:center;gap:1.5rem;padding:1.5rem";
|
|
38
|
+
const status = browserDocument.createElement("h1");
|
|
39
|
+
status.className = "next-error-h1";
|
|
40
|
+
status.textContent = String(error.status);
|
|
41
|
+
status.style.cssText = [
|
|
42
|
+
"display:inline-block",
|
|
43
|
+
"margin:0 1.25rem 0 0",
|
|
44
|
+
"padding:0 1.5rem 0 0",
|
|
45
|
+
"font-size:24px",
|
|
46
|
+
"font-weight:500",
|
|
47
|
+
"line-height:49px",
|
|
48
|
+
"vertical-align:top",
|
|
49
|
+
"border-right:1px solid rgba(0,0,0,.3)"
|
|
50
|
+
].join(";");
|
|
51
|
+
const description = browserDocument.createElement("div");
|
|
52
|
+
description.style.cssText = "display:inline-block;text-align:left;line-height:49px;height:49px;vertical-align:middle";
|
|
53
|
+
const message = browserDocument.createElement("h2");
|
|
54
|
+
message.textContent = error.message;
|
|
55
|
+
message.style.cssText = "font-size:14px;font-weight:400;line-height:49px;margin:0";
|
|
56
|
+
description.append(message);
|
|
57
|
+
wrapper.append(status, description);
|
|
58
|
+
root.replaceChildren(wrapper);
|
|
59
|
+
for (const child of Array.from(browserDocument.body.children)) {
|
|
60
|
+
if (child.id === root.id) {
|
|
61
|
+
continue;
|
|
62
|
+
}
|
|
63
|
+
child.style.display = "none";
|
|
64
|
+
}
|
|
65
|
+
if (!existingRoot) {
|
|
66
|
+
browserDocument.body.append(root);
|
|
67
|
+
}
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
export {
|
|
71
|
+
normalizeNextClientHttpError,
|
|
72
|
+
createNextRenderableError,
|
|
73
|
+
renderNextClientHttpErrorPage
|
|
74
|
+
};
|
package/dist/client.mjs
CHANGED
|
@@ -1,4 +1,9 @@
|
|
|
1
1
|
"use client";
|
|
2
|
+
import {
|
|
3
|
+
createNextRenderableError,
|
|
4
|
+
normalizeNextClientHttpError,
|
|
5
|
+
renderNextClientHttpErrorPage
|
|
6
|
+
} from "./chunk-3RI2KDLY.mjs";
|
|
2
7
|
|
|
3
8
|
// src/client.ts
|
|
4
9
|
import { useEffect, useRef, useState } from "react";
|
|
@@ -31,13 +36,22 @@ function areEqual(left, right) {
|
|
|
31
36
|
function areOptionsEqual(left, right) {
|
|
32
37
|
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);
|
|
33
38
|
}
|
|
34
|
-
function createSubmitterBridge(optionsRef) {
|
|
35
|
-
return (context) => {
|
|
39
|
+
function createSubmitterBridge(optionsRef, onHttpError) {
|
|
40
|
+
return async (context) => {
|
|
36
41
|
const submitter = optionsRef.current?.submitter;
|
|
37
42
|
if (!submitter) {
|
|
38
43
|
throw new TypeError("Expected submitter to be defined.");
|
|
39
44
|
}
|
|
40
|
-
|
|
45
|
+
try {
|
|
46
|
+
return await submitter(context);
|
|
47
|
+
} catch (error) {
|
|
48
|
+
const httpError = normalizeNextClientHttpError(error);
|
|
49
|
+
if (httpError) {
|
|
50
|
+
renderNextClientHttpErrorPage(httpError);
|
|
51
|
+
onHttpError(createNextRenderableError(httpError));
|
|
52
|
+
}
|
|
53
|
+
throw error;
|
|
54
|
+
}
|
|
41
55
|
};
|
|
42
56
|
}
|
|
43
57
|
function useForm(schemaDefinition, options = {}) {
|
|
@@ -46,10 +60,14 @@ function useForm(schemaDefinition, options = {}) {
|
|
|
46
60
|
const previousOptionsRef = useRef(void 0);
|
|
47
61
|
const latestOptionsRef = useRef(void 0);
|
|
48
62
|
const submitterBridgeRef = useRef(void 0);
|
|
63
|
+
const [httpError, setHttpError] = useState(void 0);
|
|
49
64
|
const [, setVersion] = useState(0);
|
|
65
|
+
if (httpError) {
|
|
66
|
+
throw httpError;
|
|
67
|
+
}
|
|
50
68
|
latestOptionsRef.current = options;
|
|
51
69
|
if (options.submitter && !submitterBridgeRef.current) {
|
|
52
|
-
submitterBridgeRef.current = createSubmitterBridge(latestOptionsRef);
|
|
70
|
+
submitterBridgeRef.current = createSubmitterBridge(latestOptionsRef, setHttpError);
|
|
53
71
|
}
|
|
54
72
|
const resolvedOptions = options.submitter ? {
|
|
55
73
|
...options,
|
package/dist/config.d.ts
CHANGED
|
@@ -4,6 +4,7 @@ interface TurbopackIgnoreIssueRule {
|
|
|
4
4
|
}
|
|
5
5
|
interface TurbopackConfig {
|
|
6
6
|
readonly ignoreIssue?: readonly TurbopackIgnoreIssueRule[];
|
|
7
|
+
readonly rules?: Record<string, unknown>;
|
|
7
8
|
readonly [key: string]: unknown;
|
|
8
9
|
}
|
|
9
10
|
interface NextConfig {
|
|
@@ -13,8 +14,20 @@ interface NextConfig {
|
|
|
13
14
|
readonly experimental?: Record<string, unknown>;
|
|
14
15
|
readonly turbopack?: TurbopackConfig;
|
|
15
16
|
readonly rewrites?: () => Promise<unknown>;
|
|
17
|
+
readonly webpack?: (config: WebpackConfig, context: WebpackConfigContext) => WebpackConfig;
|
|
16
18
|
readonly [key: string]: unknown;
|
|
17
19
|
}
|
|
20
|
+
type WebpackConfig = {
|
|
21
|
+
module?: {
|
|
22
|
+
rules?: unknown[];
|
|
23
|
+
[key: string]: unknown;
|
|
24
|
+
};
|
|
25
|
+
[key: string]: unknown;
|
|
26
|
+
};
|
|
27
|
+
type WebpackConfigContext = {
|
|
28
|
+
readonly isServer: boolean;
|
|
29
|
+
readonly [key: string]: unknown;
|
|
30
|
+
};
|
|
18
31
|
declare function withHolo<TConfig extends NextConfig>(nextConfig?: TConfig): TConfig;
|
|
19
32
|
|
|
20
33
|
export { withHolo };
|
package/dist/config.mjs
CHANGED
|
@@ -1,5 +1,6 @@
|
|
|
1
1
|
// src/config.ts
|
|
2
2
|
import { readFileSync } from "fs";
|
|
3
|
+
import { fileURLToPath } from "url";
|
|
3
4
|
import { join } from "path";
|
|
4
5
|
var HOLO_SERVER_EXTERNAL_PACKAGES = [
|
|
5
6
|
"@holo-js/core",
|
|
@@ -30,6 +31,7 @@ var HOLO_OPTIONAL_SERVER_EXTERNAL_PACKAGES = [
|
|
|
30
31
|
"@holo-js/queue",
|
|
31
32
|
"@holo-js/queue-db",
|
|
32
33
|
"@holo-js/queue-redis",
|
|
34
|
+
"@holo-js/realtime",
|
|
33
35
|
"@holo-js/security",
|
|
34
36
|
"@holo-js/session",
|
|
35
37
|
"@holo-js/storage",
|
|
@@ -40,6 +42,7 @@ var HOLO_TRANSPILED_PACKAGES = [
|
|
|
40
42
|
"@holo-js/auth"
|
|
41
43
|
];
|
|
42
44
|
var HOLO_TRANSPILED_PACKAGE_SET = new Set(HOLO_TRANSPILED_PACKAGES);
|
|
45
|
+
var NEXT_AUTH_INTERRUPTS_ENV = "__NEXT_EXPERIMENTAL_AUTH_INTERRUPTS";
|
|
43
46
|
var PACKAGE_DEPENDENCY_FIELDS = [
|
|
44
47
|
"dependencies",
|
|
45
48
|
"devDependencies",
|
|
@@ -70,7 +73,28 @@ function readProjectPackageManifest() {
|
|
|
70
73
|
function isOptionalServerExternalPackageInstalled(packageName, manifest) {
|
|
71
74
|
return PACKAGE_DEPENDENCY_FIELDS.some((field) => Boolean(manifest?.[field]?.[packageName]));
|
|
72
75
|
}
|
|
76
|
+
function createRealtimeDefinitionWebpackRule(loaderPath) {
|
|
77
|
+
return {
|
|
78
|
+
test: /(?:^|[\\/])server[\\/]realtime[\\/].+\.[cm]?[jt]sx?$/,
|
|
79
|
+
use: [loaderPath]
|
|
80
|
+
};
|
|
81
|
+
}
|
|
82
|
+
function createRealtimeDefinitionTurbopackRule(loaderPath) {
|
|
83
|
+
return {
|
|
84
|
+
condition: {
|
|
85
|
+
all: [
|
|
86
|
+
"browser",
|
|
87
|
+
{
|
|
88
|
+
path: /(?:^|[\\/])server[\\/]realtime[\\/]/
|
|
89
|
+
}
|
|
90
|
+
]
|
|
91
|
+
},
|
|
92
|
+
loaders: [loaderPath],
|
|
93
|
+
as: "*.js"
|
|
94
|
+
};
|
|
95
|
+
}
|
|
73
96
|
function withHolo(nextConfig = {}) {
|
|
97
|
+
process.env[NEXT_AUTH_INTERRUPTS_ENV] = "1";
|
|
74
98
|
const existingExternal = nextConfig.serverExternalPackages ?? [];
|
|
75
99
|
const packageManifest = readProjectPackageManifest();
|
|
76
100
|
const installedOptionalExternal = HOLO_OPTIONAL_SERVER_EXTERNAL_PACKAGES.filter((packageName) => isOptionalServerExternalPackageInstalled(packageName, packageManifest));
|
|
@@ -88,8 +112,18 @@ function withHolo(nextConfig = {}) {
|
|
|
88
112
|
};
|
|
89
113
|
const existingTurbopack = nextConfig.turbopack ?? {};
|
|
90
114
|
const existingIgnoreIssue = existingTurbopack.ignoreIssue ?? [];
|
|
115
|
+
const hasRealtime = isOptionalServerExternalPackageInstalled("@holo-js/realtime", packageManifest);
|
|
116
|
+
const realtimeDefinitionLoader = fileURLToPath(new URL("./realtime-definition-loader.mjs", import.meta.url));
|
|
91
117
|
const mergedTurbopack = {
|
|
92
118
|
...existingTurbopack,
|
|
119
|
+
rules: {
|
|
120
|
+
...existingTurbopack.rules ?? {},
|
|
121
|
+
...hasRealtime ? {
|
|
122
|
+
"*.{ts,tsx,js,jsx,mts,mjs,cts,cjs}": [
|
|
123
|
+
createRealtimeDefinitionTurbopackRule(realtimeDefinitionLoader)
|
|
124
|
+
]
|
|
125
|
+
} : {}
|
|
126
|
+
},
|
|
93
127
|
ignoreIssue: [
|
|
94
128
|
...existingIgnoreIssue,
|
|
95
129
|
{
|
|
@@ -99,6 +133,7 @@ function withHolo(nextConfig = {}) {
|
|
|
99
133
|
]
|
|
100
134
|
};
|
|
101
135
|
const userRewrites = nextConfig.rewrites;
|
|
136
|
+
const userWebpack = nextConfig.webpack;
|
|
102
137
|
return {
|
|
103
138
|
...nextConfig,
|
|
104
139
|
experimental: {
|
|
@@ -109,6 +144,18 @@ function withHolo(nextConfig = {}) {
|
|
|
109
144
|
transpilePackages: mergedTranspilePackages,
|
|
110
145
|
outputFileTracingExcludes: mergedExcludes,
|
|
111
146
|
turbopack: mergedTurbopack,
|
|
147
|
+
webpack(config, context) {
|
|
148
|
+
const nextWebpackConfig = userWebpack?.(config, context) ?? config;
|
|
149
|
+
if (!hasRealtime || context.isServer) {
|
|
150
|
+
return nextWebpackConfig;
|
|
151
|
+
}
|
|
152
|
+
nextWebpackConfig.module = nextWebpackConfig.module ?? {};
|
|
153
|
+
nextWebpackConfig.module.rules = [
|
|
154
|
+
...nextWebpackConfig.module.rules ?? [],
|
|
155
|
+
createRealtimeDefinitionWebpackRule(realtimeDefinitionLoader)
|
|
156
|
+
];
|
|
157
|
+
return nextWebpackConfig;
|
|
158
|
+
},
|
|
112
159
|
async rewrites() {
|
|
113
160
|
const userResult = await userRewrites?.call(this);
|
|
114
161
|
const raw = process.env.STORAGE_ROUTE_PREFIX?.trim() ?? "/storage";
|
|
@@ -0,0 +1,279 @@
|
|
|
1
|
+
// src/realtime-definition-transform.ts
|
|
2
|
+
var serverOnlyRealtimeProperties = /* @__PURE__ */ new Set(["handler", "authorize"]);
|
|
3
|
+
function isIdentifierBoundary(value) {
|
|
4
|
+
return !value || !/[$\w]/.test(value);
|
|
5
|
+
}
|
|
6
|
+
function skipString(source, index, quote) {
|
|
7
|
+
let cursor = index + 1;
|
|
8
|
+
while (cursor < source.length) {
|
|
9
|
+
const char = source[cursor];
|
|
10
|
+
if (char === "\\") {
|
|
11
|
+
cursor += 2;
|
|
12
|
+
continue;
|
|
13
|
+
}
|
|
14
|
+
if (char === quote) {
|
|
15
|
+
return cursor + 1;
|
|
16
|
+
}
|
|
17
|
+
cursor += 1;
|
|
18
|
+
}
|
|
19
|
+
return cursor;
|
|
20
|
+
}
|
|
21
|
+
function skipLineComment(source, index) {
|
|
22
|
+
const end = source.indexOf("\n", index + 2);
|
|
23
|
+
return end === -1 ? source.length : end + 1;
|
|
24
|
+
}
|
|
25
|
+
function skipBlockComment(source, index) {
|
|
26
|
+
const end = source.indexOf("*/", index + 2);
|
|
27
|
+
return end === -1 ? source.length : end + 2;
|
|
28
|
+
}
|
|
29
|
+
function findRealtimePropertyValueEnd(source, index) {
|
|
30
|
+
let cursor = index;
|
|
31
|
+
let braceDepth = 0;
|
|
32
|
+
let bracketDepth = 0;
|
|
33
|
+
let parenDepth = 0;
|
|
34
|
+
while (cursor < source.length) {
|
|
35
|
+
const char = source[cursor];
|
|
36
|
+
const next = source[cursor + 1];
|
|
37
|
+
if (char === '"' || char === "'" || char === "`") {
|
|
38
|
+
cursor = skipString(source, cursor, char);
|
|
39
|
+
continue;
|
|
40
|
+
}
|
|
41
|
+
if (char === "/" && next === "/") {
|
|
42
|
+
cursor = skipLineComment(source, cursor);
|
|
43
|
+
continue;
|
|
44
|
+
}
|
|
45
|
+
if (char === "/" && next === "*") {
|
|
46
|
+
cursor = skipBlockComment(source, cursor);
|
|
47
|
+
continue;
|
|
48
|
+
}
|
|
49
|
+
if (char === "{") {
|
|
50
|
+
braceDepth += 1;
|
|
51
|
+
} else if (char === "}") {
|
|
52
|
+
if (braceDepth === 0 && bracketDepth === 0 && parenDepth === 0) {
|
|
53
|
+
return cursor;
|
|
54
|
+
}
|
|
55
|
+
braceDepth -= 1;
|
|
56
|
+
} else if (char === "[") {
|
|
57
|
+
bracketDepth += 1;
|
|
58
|
+
} else if (char === "]") {
|
|
59
|
+
bracketDepth -= 1;
|
|
60
|
+
} else if (char === "(") {
|
|
61
|
+
parenDepth += 1;
|
|
62
|
+
} else if (char === ")") {
|
|
63
|
+
parenDepth -= 1;
|
|
64
|
+
} else if (char === "," && braceDepth === 0 && bracketDepth === 0 && parenDepth === 0) {
|
|
65
|
+
return cursor;
|
|
66
|
+
}
|
|
67
|
+
cursor += 1;
|
|
68
|
+
}
|
|
69
|
+
return source.length;
|
|
70
|
+
}
|
|
71
|
+
function findClosingBrace(source, index) {
|
|
72
|
+
let cursor = index;
|
|
73
|
+
let depth = 0;
|
|
74
|
+
while (cursor < source.length) {
|
|
75
|
+
const char = source[cursor];
|
|
76
|
+
const next = source[cursor + 1];
|
|
77
|
+
if (char === '"' || char === "'" || char === "`") {
|
|
78
|
+
cursor = skipString(source, cursor, char);
|
|
79
|
+
continue;
|
|
80
|
+
}
|
|
81
|
+
if (char === "/" && next === "/") {
|
|
82
|
+
cursor = skipLineComment(source, cursor);
|
|
83
|
+
continue;
|
|
84
|
+
}
|
|
85
|
+
if (char === "/" && next === "*") {
|
|
86
|
+
cursor = skipBlockComment(source, cursor);
|
|
87
|
+
continue;
|
|
88
|
+
}
|
|
89
|
+
if (char === "{") {
|
|
90
|
+
depth += 1;
|
|
91
|
+
} else if (char === "}") {
|
|
92
|
+
depth -= 1;
|
|
93
|
+
if (depth === 0) {
|
|
94
|
+
return cursor;
|
|
95
|
+
}
|
|
96
|
+
}
|
|
97
|
+
cursor += 1;
|
|
98
|
+
}
|
|
99
|
+
return -1;
|
|
100
|
+
}
|
|
101
|
+
function applyReplacements(source, replacements) {
|
|
102
|
+
if (replacements.length === 0) {
|
|
103
|
+
return source;
|
|
104
|
+
}
|
|
105
|
+
let output = "";
|
|
106
|
+
let cursor = 0;
|
|
107
|
+
const ordered = [...replacements].sort((left, right) => left.start - right.start);
|
|
108
|
+
for (const replacement of ordered) {
|
|
109
|
+
output += source.slice(cursor, replacement.start);
|
|
110
|
+
output += replacement.text;
|
|
111
|
+
cursor = replacement.end;
|
|
112
|
+
}
|
|
113
|
+
return output + source.slice(cursor);
|
|
114
|
+
}
|
|
115
|
+
function extractObjectPropertyValue(objectSource, propertyName) {
|
|
116
|
+
let cursor = 1;
|
|
117
|
+
while (cursor < objectSource.length - 1) {
|
|
118
|
+
const char = objectSource[cursor];
|
|
119
|
+
const next = objectSource[cursor + 1];
|
|
120
|
+
if (char === '"' || char === "'" || char === "`") {
|
|
121
|
+
cursor = skipString(objectSource, cursor, char);
|
|
122
|
+
continue;
|
|
123
|
+
}
|
|
124
|
+
if (char === "/" && next === "/") {
|
|
125
|
+
cursor = skipLineComment(objectSource, cursor);
|
|
126
|
+
continue;
|
|
127
|
+
}
|
|
128
|
+
if (char === "/" && next === "*") {
|
|
129
|
+
cursor = skipBlockComment(objectSource, cursor);
|
|
130
|
+
continue;
|
|
131
|
+
}
|
|
132
|
+
const match = objectSource.slice(cursor).match(/^[$A-Z_a-z][$\w]*/);
|
|
133
|
+
const name = match?.[0];
|
|
134
|
+
if (!name || name !== propertyName) {
|
|
135
|
+
cursor += 1;
|
|
136
|
+
continue;
|
|
137
|
+
}
|
|
138
|
+
const afterName = cursor + name.length;
|
|
139
|
+
if (!isIdentifierBoundary(objectSource[cursor - 1]) || !isIdentifierBoundary(objectSource[afterName])) {
|
|
140
|
+
cursor += name.length;
|
|
141
|
+
continue;
|
|
142
|
+
}
|
|
143
|
+
let colon = afterName;
|
|
144
|
+
while (/\s/.test(objectSource[colon] ?? "")) {
|
|
145
|
+
colon += 1;
|
|
146
|
+
}
|
|
147
|
+
if (objectSource[colon] !== ":") {
|
|
148
|
+
cursor += name.length;
|
|
149
|
+
continue;
|
|
150
|
+
}
|
|
151
|
+
const valueStart = colon + 1;
|
|
152
|
+
const valueEnd = findRealtimePropertyValueEnd(objectSource, valueStart);
|
|
153
|
+
return objectSource.slice(valueStart, valueEnd).trim();
|
|
154
|
+
}
|
|
155
|
+
return void 0;
|
|
156
|
+
}
|
|
157
|
+
function collectRealtimeDefinitionExports(source) {
|
|
158
|
+
const definitions = [];
|
|
159
|
+
let cursor = 0;
|
|
160
|
+
while (cursor < source.length) {
|
|
161
|
+
const char = source[cursor];
|
|
162
|
+
const next = source[cursor + 1];
|
|
163
|
+
if (char === '"' || char === "'" || char === "`") {
|
|
164
|
+
cursor = skipString(source, cursor, char);
|
|
165
|
+
continue;
|
|
166
|
+
}
|
|
167
|
+
if (char === "/" && next === "/") {
|
|
168
|
+
cursor = skipLineComment(source, cursor);
|
|
169
|
+
continue;
|
|
170
|
+
}
|
|
171
|
+
if (char === "/" && next === "*") {
|
|
172
|
+
cursor = skipBlockComment(source, cursor);
|
|
173
|
+
continue;
|
|
174
|
+
}
|
|
175
|
+
const match = source.slice(cursor).match(/^export\s+const\s+([$A-Z_a-z][$\w]*)\s*=\s*(query|mutation)\s*\(/);
|
|
176
|
+
const exportedName = match?.[1];
|
|
177
|
+
const factoryName = match?.[2];
|
|
178
|
+
if (!exportedName || !factoryName) {
|
|
179
|
+
cursor += 1;
|
|
180
|
+
continue;
|
|
181
|
+
}
|
|
182
|
+
let objectStart = cursor + match[0].length;
|
|
183
|
+
while (/\s/.test(source[objectStart] ?? "")) {
|
|
184
|
+
objectStart += 1;
|
|
185
|
+
}
|
|
186
|
+
if (source[objectStart] !== "{") {
|
|
187
|
+
cursor += match[0].length;
|
|
188
|
+
continue;
|
|
189
|
+
}
|
|
190
|
+
const objectEnd = findClosingBrace(source, objectStart);
|
|
191
|
+
if (objectEnd === -1) {
|
|
192
|
+
cursor += match[0].length;
|
|
193
|
+
continue;
|
|
194
|
+
}
|
|
195
|
+
const objectSource = source.slice(objectStart, objectEnd + 1);
|
|
196
|
+
definitions.push({
|
|
197
|
+
exportedName,
|
|
198
|
+
factoryName,
|
|
199
|
+
nameValue: extractObjectPropertyValue(objectSource, "name")
|
|
200
|
+
});
|
|
201
|
+
cursor = objectEnd + 1;
|
|
202
|
+
}
|
|
203
|
+
return definitions;
|
|
204
|
+
}
|
|
205
|
+
function createRealtimeClientDefinitionModule(source) {
|
|
206
|
+
const definitions = collectRealtimeDefinitionExports(source);
|
|
207
|
+
if (definitions.length === 0) {
|
|
208
|
+
return stripRealtimeServerHandlers(source);
|
|
209
|
+
}
|
|
210
|
+
const factories = [...new Set(definitions.map((definition) => definition.factoryName))];
|
|
211
|
+
return [
|
|
212
|
+
`import { ${factories.join(", ")} } from '@holo-js/adapter-next/realtime'`,
|
|
213
|
+
"",
|
|
214
|
+
...definitions.flatMap((definition) => [
|
|
215
|
+
`export const ${definition.exportedName} = ${definition.factoryName}({`,
|
|
216
|
+
...definition.nameValue ? [` name: ${definition.nameValue},`] : [],
|
|
217
|
+
" handler: undefined,",
|
|
218
|
+
"})",
|
|
219
|
+
""
|
|
220
|
+
])
|
|
221
|
+
].join("\n");
|
|
222
|
+
}
|
|
223
|
+
function stripRealtimeServerHandlers(source) {
|
|
224
|
+
const replacements = [];
|
|
225
|
+
let cursor = 0;
|
|
226
|
+
while (cursor < source.length) {
|
|
227
|
+
const char = source[cursor];
|
|
228
|
+
const next = source[cursor + 1];
|
|
229
|
+
if (char === '"' || char === "'" || char === "`") {
|
|
230
|
+
cursor = skipString(source, cursor, char);
|
|
231
|
+
continue;
|
|
232
|
+
}
|
|
233
|
+
if (char === "/" && next === "/") {
|
|
234
|
+
cursor = skipLineComment(source, cursor);
|
|
235
|
+
continue;
|
|
236
|
+
}
|
|
237
|
+
if (char === "/" && next === "*") {
|
|
238
|
+
cursor = skipBlockComment(source, cursor);
|
|
239
|
+
continue;
|
|
240
|
+
}
|
|
241
|
+
const match = source.slice(cursor).match(/^[$A-Z_a-z][$\w]*/);
|
|
242
|
+
const name = match?.[0];
|
|
243
|
+
if (!name || !serverOnlyRealtimeProperties.has(name)) {
|
|
244
|
+
cursor += 1;
|
|
245
|
+
continue;
|
|
246
|
+
}
|
|
247
|
+
const afterName = cursor + name.length;
|
|
248
|
+
if (!isIdentifierBoundary(source[cursor - 1]) || !isIdentifierBoundary(source[afterName])) {
|
|
249
|
+
cursor += name.length;
|
|
250
|
+
continue;
|
|
251
|
+
}
|
|
252
|
+
let colon = afterName;
|
|
253
|
+
while (/\s/.test(source[colon] ?? "")) {
|
|
254
|
+
colon += 1;
|
|
255
|
+
}
|
|
256
|
+
if (source[colon] !== ":") {
|
|
257
|
+
cursor += name.length;
|
|
258
|
+
continue;
|
|
259
|
+
}
|
|
260
|
+
const valueStart = colon + 1;
|
|
261
|
+
const valueEnd = findRealtimePropertyValueEnd(source, valueStart);
|
|
262
|
+
replacements.push({
|
|
263
|
+
start: valueStart,
|
|
264
|
+
end: valueEnd,
|
|
265
|
+
text: " undefined"
|
|
266
|
+
});
|
|
267
|
+
cursor = valueEnd;
|
|
268
|
+
}
|
|
269
|
+
return applyReplacements(source, replacements);
|
|
270
|
+
}
|
|
271
|
+
|
|
272
|
+
// src/realtime-definition-loader.ts
|
|
273
|
+
function realtimeDefinitionLoader(source) {
|
|
274
|
+
this.cacheable?.();
|
|
275
|
+
return createRealtimeClientDefinitionModule(source);
|
|
276
|
+
}
|
|
277
|
+
export {
|
|
278
|
+
realtimeDefinitionLoader as default
|
|
279
|
+
};
|
|
@@ -0,0 +1,113 @@
|
|
|
1
|
+
"use client";
|
|
2
|
+
import {
|
|
3
|
+
createNextRenderableError,
|
|
4
|
+
normalizeNextClientHttpError,
|
|
5
|
+
renderNextClientHttpErrorPage
|
|
6
|
+
} from "./chunk-3RI2KDLY.mjs";
|
|
7
|
+
|
|
8
|
+
// src/realtime.ts
|
|
9
|
+
import { useEffect, useSyncExternalStore } from "react";
|
|
10
|
+
import {
|
|
11
|
+
configureRealtimeClientRuntime,
|
|
12
|
+
configureRealtimeClientTransport,
|
|
13
|
+
createBroadcastRealtimeTransport,
|
|
14
|
+
getRealtimeQueryStore
|
|
15
|
+
} from "@holo-js/realtime/client";
|
|
16
|
+
import {
|
|
17
|
+
mutation as createRealtimeMutation,
|
|
18
|
+
query as createRealtimeQuery
|
|
19
|
+
} from "@holo-js/realtime";
|
|
20
|
+
var currentRealtimeError;
|
|
21
|
+
var realtimeErrorListeners = /* @__PURE__ */ new Set();
|
|
22
|
+
function subscribeRealtimeError(listener) {
|
|
23
|
+
realtimeErrorListeners.add(listener);
|
|
24
|
+
return () => {
|
|
25
|
+
realtimeErrorListeners.delete(listener);
|
|
26
|
+
};
|
|
27
|
+
}
|
|
28
|
+
function emitRealtimeError(error) {
|
|
29
|
+
const httpError = normalizeNextClientHttpError(error);
|
|
30
|
+
if (!httpError) {
|
|
31
|
+
return;
|
|
32
|
+
}
|
|
33
|
+
currentRealtimeError = createNextRenderableError(httpError);
|
|
34
|
+
renderNextClientHttpErrorPage(httpError);
|
|
35
|
+
for (const listener of realtimeErrorListeners) {
|
|
36
|
+
listener();
|
|
37
|
+
}
|
|
38
|
+
}
|
|
39
|
+
function getRealtimeErrorSnapshot() {
|
|
40
|
+
return currentRealtimeError;
|
|
41
|
+
}
|
|
42
|
+
function consumeRealtimeError() {
|
|
43
|
+
const error = currentRealtimeError;
|
|
44
|
+
currentRealtimeError = void 0;
|
|
45
|
+
return error;
|
|
46
|
+
}
|
|
47
|
+
function createErrorHandlingRealtimeTransport(transport) {
|
|
48
|
+
return {
|
|
49
|
+
async query(name, args) {
|
|
50
|
+
try {
|
|
51
|
+
return await transport.query(name, args);
|
|
52
|
+
} catch (error) {
|
|
53
|
+
emitRealtimeError(error);
|
|
54
|
+
throw error;
|
|
55
|
+
}
|
|
56
|
+
},
|
|
57
|
+
async mutate(name, args) {
|
|
58
|
+
try {
|
|
59
|
+
return await transport.mutate(name, args);
|
|
60
|
+
} catch (error) {
|
|
61
|
+
emitRealtimeError(error);
|
|
62
|
+
throw error;
|
|
63
|
+
}
|
|
64
|
+
},
|
|
65
|
+
subscribe(name, args, listener, onError) {
|
|
66
|
+
return transport.subscribe(name, args, listener, (error) => {
|
|
67
|
+
emitRealtimeError(error);
|
|
68
|
+
onError(error);
|
|
69
|
+
});
|
|
70
|
+
}
|
|
71
|
+
};
|
|
72
|
+
}
|
|
73
|
+
var query = createRealtimeQuery;
|
|
74
|
+
var mutation = ((input) => {
|
|
75
|
+
const definition = createRealtimeMutation(input);
|
|
76
|
+
const wrappedDefinition = ((...args) => {
|
|
77
|
+
const result = Reflect.apply(definition, void 0, args);
|
|
78
|
+
void result.catch(emitRealtimeError);
|
|
79
|
+
return result;
|
|
80
|
+
});
|
|
81
|
+
Object.defineProperties(wrappedDefinition, Object.getOwnPropertyDescriptors(definition));
|
|
82
|
+
return wrappedDefinition;
|
|
83
|
+
});
|
|
84
|
+
function useReactiveRealtimeQuery(definition, args) {
|
|
85
|
+
const realtimeError = useSyncExternalStore(
|
|
86
|
+
subscribeRealtimeError,
|
|
87
|
+
getRealtimeErrorSnapshot,
|
|
88
|
+
getRealtimeErrorSnapshot
|
|
89
|
+
);
|
|
90
|
+
if (realtimeError) {
|
|
91
|
+
consumeRealtimeError();
|
|
92
|
+
throw realtimeError;
|
|
93
|
+
}
|
|
94
|
+
const store = getRealtimeQueryStore(definition, args);
|
|
95
|
+
useEffect(() => {
|
|
96
|
+
store.connect();
|
|
97
|
+
}, [store]);
|
|
98
|
+
const snapshot = useSyncExternalStore(
|
|
99
|
+
store.subscribe,
|
|
100
|
+
() => store.snapshot,
|
|
101
|
+
() => store.snapshot
|
|
102
|
+
);
|
|
103
|
+
return snapshot?.data;
|
|
104
|
+
}
|
|
105
|
+
configureRealtimeClientRuntime({
|
|
106
|
+
handleError: emitRealtimeError,
|
|
107
|
+
useQuery: useReactiveRealtimeQuery
|
|
108
|
+
});
|
|
109
|
+
configureRealtimeClientTransport(createErrorHandlingRealtimeTransport(createBroadcastRealtimeTransport()));
|
|
110
|
+
export {
|
|
111
|
+
mutation,
|
|
112
|
+
query
|
|
113
|
+
};
|
package/dist/runtime.d.ts
CHANGED
|
@@ -55,6 +55,7 @@ interface GeneratedChannelRegistryEntry {
|
|
|
55
55
|
readonly sourcePath: string;
|
|
56
56
|
readonly pattern: string;
|
|
57
57
|
readonly exportName?: string;
|
|
58
|
+
readonly guard?: string;
|
|
58
59
|
readonly type: 'private' | 'presence';
|
|
59
60
|
readonly params: readonly string[];
|
|
60
61
|
readonly whispers: readonly string[];
|
|
@@ -115,6 +116,7 @@ declare function runWithNextRequest<TValue>(request: NextRequestLike, callback:
|
|
|
115
116
|
type NextHoloRuntimeOptions = CreateHoloOptions & {
|
|
116
117
|
readonly projectRoot: string;
|
|
117
118
|
};
|
|
119
|
+
declare function createNextRequestContext(request: Request): NextRequestLike;
|
|
118
120
|
declare function createNextHoloHelpers<TCustom extends HoloConfigMap = HoloConfigMap>(options: NextHoloRuntimeOptions): {
|
|
119
121
|
getApp(): Promise<{
|
|
120
122
|
projectRoot: string;
|
|
@@ -134,4 +136,4 @@ declare function createNextHoloHelpers<TCustom extends HoloConfigMap = HoloConfi
|
|
|
134
136
|
config: <TPath extends DotPath<LoadedHoloConfig<TCustom>["all"]>>(path: TPath) => Promise<ValueAtPath<LoadedHoloConfig<TCustom>["all"], TPath>>;
|
|
135
137
|
};
|
|
136
138
|
|
|
137
|
-
export { type NextHoloRuntimeOptions, type NextRequestLike, createNextHoloHelpers, runWithNextRequest };
|
|
139
|
+
export { type NextHoloRuntimeOptions, type NextRequestLike, createNextHoloHelpers, createNextRequestContext, runWithNextRequest };
|
package/dist/runtime.mjs
CHANGED
|
@@ -1,5 +1,4 @@
|
|
|
1
1
|
// src/runtime.ts
|
|
2
|
-
import { createRequire } from "module";
|
|
3
2
|
import { initializeHolo } from "@holo-js/core";
|
|
4
3
|
|
|
5
4
|
// src/request-context.ts
|
|
@@ -17,7 +16,11 @@ function runWithNextRequest(request, callback) {
|
|
|
17
16
|
}
|
|
18
17
|
|
|
19
18
|
// src/runtime.ts
|
|
20
|
-
|
|
19
|
+
function createNextHttpAccessFallbackError(status, message) {
|
|
20
|
+
const error = new Error(message);
|
|
21
|
+
error.digest = `NEXT_HTTP_ERROR_FALLBACK;${status}`;
|
|
22
|
+
throw error;
|
|
23
|
+
}
|
|
21
24
|
function safeDecodeCookieSegment(value) {
|
|
22
25
|
try {
|
|
23
26
|
return decodeURIComponent(value);
|
|
@@ -83,6 +86,38 @@ function parseResponseCookie(cookie) {
|
|
|
83
86
|
options
|
|
84
87
|
};
|
|
85
88
|
}
|
|
89
|
+
function parseRequestCookies(header) {
|
|
90
|
+
const cookies = /* @__PURE__ */ new Map();
|
|
91
|
+
for (const segment of header?.split(";") ?? []) {
|
|
92
|
+
const separator = segment.indexOf("=");
|
|
93
|
+
if (separator <= 0) {
|
|
94
|
+
continue;
|
|
95
|
+
}
|
|
96
|
+
const name = safeDecodeCookieSegment(segment.slice(0, separator).trim());
|
|
97
|
+
const value = safeDecodeCookieSegment(segment.slice(separator + 1).trim());
|
|
98
|
+
if (name) {
|
|
99
|
+
cookies.set(name, value);
|
|
100
|
+
}
|
|
101
|
+
}
|
|
102
|
+
return cookies;
|
|
103
|
+
}
|
|
104
|
+
function createNextRequestContext(request) {
|
|
105
|
+
const nextRequest = request;
|
|
106
|
+
const parsedCookies = nextRequest.cookies ? void 0 : parseRequestCookies(request.headers.get("cookie"));
|
|
107
|
+
return {
|
|
108
|
+
headers: request.headers,
|
|
109
|
+
cookies: {
|
|
110
|
+
get(name) {
|
|
111
|
+
const nextCookie = nextRequest.cookies?.get(name);
|
|
112
|
+
if (nextCookie && typeof nextCookie.value === "string") {
|
|
113
|
+
return { value: nextCookie.value };
|
|
114
|
+
}
|
|
115
|
+
const value = parsedCookies?.get(name);
|
|
116
|
+
return typeof value === "string" ? { value } : void 0;
|
|
117
|
+
}
|
|
118
|
+
}
|
|
119
|
+
};
|
|
120
|
+
}
|
|
86
121
|
function resolveNextAuthRequestAccessors() {
|
|
87
122
|
return {
|
|
88
123
|
async getCookie(name) {
|
|
@@ -124,11 +159,10 @@ function createNextHoloHelpers(options) {
|
|
|
124
159
|
authRequest: options.authRequest ?? resolveNextAuthRequestAccessors(),
|
|
125
160
|
authorizationError: options.authorizationError ?? {
|
|
126
161
|
createError(decision) {
|
|
127
|
-
const { forbidden, notFound } = requireNextModule("next/navigation.js");
|
|
128
162
|
if (decision.status === 404) {
|
|
129
|
-
return
|
|
163
|
+
return createNextHttpAccessFallbackError(404, decision.message ?? "Resource not found.");
|
|
130
164
|
}
|
|
131
|
-
return
|
|
165
|
+
return createNextHttpAccessFallbackError(403, decision.message ?? "Forbidden");
|
|
132
166
|
}
|
|
133
167
|
}
|
|
134
168
|
});
|
|
@@ -136,24 +170,21 @@ function createNextHoloHelpers(options) {
|
|
|
136
170
|
const runtime = await resolveRuntime();
|
|
137
171
|
return runtime.config(path);
|
|
138
172
|
};
|
|
173
|
+
const resolveRuntimeProjection = async () => {
|
|
174
|
+
const runtime = await resolveRuntime();
|
|
175
|
+
return {
|
|
176
|
+
projectRoot: runtime.projectRoot,
|
|
177
|
+
config: runtime.loadedConfig,
|
|
178
|
+
registry: runtime.registry,
|
|
179
|
+
runtime
|
|
180
|
+
};
|
|
181
|
+
};
|
|
139
182
|
return {
|
|
140
183
|
async getApp() {
|
|
141
|
-
|
|
142
|
-
return {
|
|
143
|
-
projectRoot: runtime.projectRoot,
|
|
144
|
-
config: runtime.loadedConfig,
|
|
145
|
-
registry: runtime.registry,
|
|
146
|
-
runtime
|
|
147
|
-
};
|
|
184
|
+
return await resolveRuntimeProjection();
|
|
148
185
|
},
|
|
149
186
|
async getProject() {
|
|
150
|
-
|
|
151
|
-
return {
|
|
152
|
-
projectRoot: runtime.projectRoot,
|
|
153
|
-
config: runtime.loadedConfig,
|
|
154
|
-
registry: runtime.registry,
|
|
155
|
-
runtime
|
|
156
|
-
};
|
|
187
|
+
return await resolveRuntimeProjection();
|
|
157
188
|
},
|
|
158
189
|
async getSession() {
|
|
159
190
|
const runtime = await resolveRuntime();
|
|
@@ -169,5 +200,6 @@ function createNextHoloHelpers(options) {
|
|
|
169
200
|
}
|
|
170
201
|
export {
|
|
171
202
|
createNextHoloHelpers,
|
|
203
|
+
createNextRequestContext,
|
|
172
204
|
runWithNextRequest
|
|
173
205
|
};
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@holo-js/adapter-next",
|
|
3
|
-
"version": "0.1
|
|
3
|
+
"version": "0.2.1",
|
|
4
4
|
"description": "Holo-JS Framework - Next.js adapter",
|
|
5
5
|
"type": "module",
|
|
6
6
|
"license": "MIT",
|
|
@@ -20,6 +20,11 @@
|
|
|
20
20
|
"import": "./dist/client.mjs",
|
|
21
21
|
"default": "./dist/client.mjs"
|
|
22
22
|
},
|
|
23
|
+
"./realtime": {
|
|
24
|
+
"types": "./dist/realtime.d.ts",
|
|
25
|
+
"import": "./dist/realtime.mjs",
|
|
26
|
+
"default": "./dist/realtime.mjs"
|
|
27
|
+
},
|
|
23
28
|
"./runtime": {
|
|
24
29
|
"types": "./dist/runtime.d.ts",
|
|
25
30
|
"import": "./dist/runtime.mjs",
|
|
@@ -38,20 +43,25 @@
|
|
|
38
43
|
"test": "vitest --run"
|
|
39
44
|
},
|
|
40
45
|
"dependencies": {
|
|
41
|
-
"@holo-js/config": "^0.1
|
|
42
|
-
"@holo-js/core": "^0.1
|
|
46
|
+
"@holo-js/config": "^0.2.1",
|
|
47
|
+
"@holo-js/core": "^0.2.1"
|
|
43
48
|
},
|
|
44
49
|
"peerDependencies": {
|
|
45
|
-
"@holo-js/forms": "^0.1
|
|
50
|
+
"@holo-js/forms": "^0.2.1",
|
|
51
|
+
"@holo-js/realtime": "^0.2.1",
|
|
46
52
|
"next": "^16.2.4",
|
|
47
53
|
"react": "^19.2.6"
|
|
48
54
|
},
|
|
49
55
|
"peerDependenciesMeta": {
|
|
50
56
|
"@holo-js/forms": {
|
|
51
57
|
"optional": true
|
|
58
|
+
},
|
|
59
|
+
"@holo-js/realtime": {
|
|
60
|
+
"optional": true
|
|
52
61
|
}
|
|
53
62
|
},
|
|
54
63
|
"devDependencies": {
|
|
64
|
+
"@holo-js/realtime": "^0.2.1",
|
|
55
65
|
"@types/node": "^22.10.2",
|
|
56
66
|
"next": "^16.2.4",
|
|
57
67
|
"tsup": "^8.3.5",
|