eddev 2.0.0-beta.222 → 2.0.0-beta.223

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.
Files changed (7) hide show
  1. package/dist/app/server/server-context.js +1 -1
  2. package/dist/node/project/config.d.ts +66 -66
  3. package/dist/node/project/config.d.ts.map +1 -1
  4. package/dist/node/project/config.js +4 -1
  5. package/dist/node/types/block-type.d.ts +26 -26
  6. package/dist/node/types/view-type.d.ts +7 -7
  7. package/package.json +1 -1
package/dist/app/server/server-context.js CHANGED
@@ -173,7 +173,7 @@ export class ServerContext {
173
173
  * For route data, the cache key is the pathname.
174
174
  * TODO: Potential support for Vercel draft mode.
175
175
  */
176
- let cacheKey = "fetchRouteData:" + req.pathname;
176
+ let cacheKey = "fetchRouteData:" + withTrailingSlash(req.pathname.toLowerCase());
177
177
  const result = await swr({
178
178
  key: cacheKey,
179
179
  cache: pageCache,
package/dist/node/project/config.d.ts CHANGED
@@ -9,20 +9,20 @@ export declare const EDConfigSchema: z.ZodObject<{
9
9
  provider: z.ZodLiteral<"ga4">;
10
10
  id: z.ZodString;
11
11
  }, "strip", z.ZodTypeAny, {
12
- id: string;
13
12
  provider: "ga4";
14
- }, {
15
13
  id: string;
14
+ }, {
16
15
  provider: "ga4";
16
+ id: string;
17
17
  }>, z.ZodObject<{
18
18
  provider: z.ZodLiteral<"gtm">;
19
19
  id: z.ZodString;
20
20
  }, "strip", z.ZodTypeAny, {
21
- id: string;
22
21
  provider: "gtm";
23
- }, {
24
22
  id: string;
23
+ }, {
25
24
  provider: "gtm";
25
+ id: string;
26
26
  }>]>, "many">>;
27
27
  serverless: z.ZodObject<{
28
28
  enabled: z.ZodDefault<z.ZodBoolean>;
@@ -52,32 +52,32 @@ export declare const EDConfigSchema: z.ZodObject<{
52
52
  commonOrigins: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
53
53
  values: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>>;
54
54
  }, "strip", z.ZodTypeAny, {
55
- nonce: boolean;
56
55
  enabled: boolean;
57
56
  autoDetect: boolean;
57
+ nonce: boolean;
58
58
  values?: Record<string, string[]> | undefined;
59
59
  commonOrigins?: string[] | undefined;
60
60
  }, {
61
61
  enabled: boolean;
62
62
  values?: Record<string, string[]> | undefined;
63
- nonce?: boolean | undefined;
64
63
  autoDetect?: boolean | undefined;
64
+ nonce?: boolean | undefined;
65
65
  commonOrigins?: string[] | undefined;
66
66
  }>>;
67
67
  }, "strip", z.ZodTypeAny, {
68
- plugins: "proxy" | "remote";
69
68
  enabled: boolean;
70
69
  uploads: "proxy" | "remote";
71
- admin: "hide" | "proxy";
70
+ plugins: "proxy" | "remote";
71
+ admin: "proxy" | "hide";
72
72
  originProtection: {
73
73
  requireLogin: boolean;
74
74
  };
75
75
  themeAssets: string[];
76
76
  endpoints: Record<string, string>;
77
77
  csp: {
78
- nonce: boolean;
79
78
  enabled: boolean;
80
79
  autoDetect: boolean;
80
+ nonce: boolean;
81
81
  values?: Record<string, string[]> | undefined;
82
82
  commonOrigins?: string[] | undefined;
83
83
  };
@@ -87,9 +87,9 @@ export declare const EDConfigSchema: z.ZodObject<{
87
87
  }, {
88
88
  uploads: "proxy" | "remote";
89
89
  endpoints: Record<string, string>;
90
- plugins?: "proxy" | "remote" | undefined;
91
90
  enabled?: boolean | undefined;
92
- admin?: "hide" | "proxy" | undefined;
91
+ plugins?: "proxy" | "remote" | undefined;
92
+ admin?: "proxy" | "hide" | undefined;
93
93
  originProtection?: {
94
94
  requireLogin?: boolean | undefined;
95
95
  } | undefined;
@@ -100,22 +100,22 @@ export declare const EDConfigSchema: z.ZodObject<{
100
100
  csp?: {
101
101
  enabled: boolean;
102
102
  values?: Record<string, string[]> | undefined;
103
- nonce?: boolean | undefined;
104
103
  autoDetect?: boolean | undefined;
104
+ nonce?: boolean | undefined;
105
105
  commonOrigins?: string[] | undefined;
106
106
  } | undefined;
107
107
  }>;
108
108
  cache: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
109
109
  wordpress: z.ZodDefault<z.ZodOptional<z.ZodObject<{
110
- strategy: z.ZodEnum<["always", "ssr-always-fresh"]>;
110
+ strategy: z.ZodOptional<z.ZodEnum<["always", "ssr-always-fresh"]>>;
111
111
  cacheHeaders: z.ZodDefault<z.ZodBoolean>;
112
112
  transients: z.ZodDefault<z.ZodBoolean>;
113
113
  }, "strip", z.ZodTypeAny, {
114
- strategy: "always" | "ssr-always-fresh";
115
114
  cacheHeaders: boolean;
116
115
  transients: boolean;
116
+ strategy?: "always" | "ssr-always-fresh" | undefined;
117
117
  }, {
118
- strategy: "always" | "ssr-always-fresh";
118
+ strategy?: "always" | "ssr-always-fresh" | undefined;
119
119
  cacheHeaders?: boolean | undefined;
120
120
  transients?: boolean | undefined;
121
121
  }>>>;
@@ -124,37 +124,37 @@ export declare const EDConfigSchema: z.ZodObject<{
124
124
  dataCache: z.ZodDefault<z.ZodEnum<["in-memory", "kv", "none"]>>;
125
125
  }, "strip", z.ZodTypeAny, {
126
126
  isr: boolean;
127
- dataCache: "none" | "in-memory" | "kv";
127
+ dataCache: "in-memory" | "kv" | "none";
128
128
  }, {
129
129
  isr?: boolean | undefined;
130
- dataCache?: "none" | "in-memory" | "kv" | undefined;
130
+ dataCache?: "in-memory" | "kv" | "none" | undefined;
131
131
  }>>>;
132
132
  pageDataTTL: z.ZodDefault<z.ZodNumber>;
133
133
  appDataTTL: z.ZodDefault<z.ZodNumber>;
134
134
  queryHooksTTL: z.ZodDefault<z.ZodNumber>;
135
135
  }, "strip", z.ZodTypeAny, {
136
+ serverless: {
137
+ isr: boolean;
138
+ dataCache: "in-memory" | "kv" | "none";
139
+ };
136
140
  wordpress: {
137
- strategy: "always" | "ssr-always-fresh";
138
141
  cacheHeaders: boolean;
139
142
  transients: boolean;
140
- };
141
- serverless: {
142
- isr: boolean;
143
- dataCache: "none" | "in-memory" | "kv";
143
+ strategy?: "always" | "ssr-always-fresh" | undefined;
144
144
  };
145
145
  pageDataTTL: number;
146
146
  appDataTTL: number;
147
147
  queryHooksTTL: number;
148
148
  }, {
149
+ serverless?: {
150
+ isr?: boolean | undefined;
151
+ dataCache?: "in-memory" | "kv" | "none" | undefined;
152
+ } | undefined;
149
153
  wordpress?: {
150
- strategy: "always" | "ssr-always-fresh";
154
+ strategy?: "always" | "ssr-always-fresh" | undefined;
151
155
  cacheHeaders?: boolean | undefined;
152
156
  transients?: boolean | undefined;
153
157
  } | undefined;
154
- serverless?: {
155
- isr?: boolean | undefined;
156
- dataCache?: "none" | "in-memory" | "kv" | undefined;
157
- } | undefined;
158
158
  pageDataTTL?: number | undefined;
159
159
  appDataTTL?: number | undefined;
160
160
  queryHooksTTL?: number | undefined;
@@ -162,36 +162,22 @@ export declare const EDConfigSchema: z.ZodObject<{
162
162
  devUI: z.ZodDefault<z.ZodEnum<["disabled", "enabled"]>>;
163
163
  }, "strip", z.ZodTypeAny, {
164
164
  version: "2";
165
- cache: Record<string, {
166
- wordpress: {
167
- strategy: "always" | "ssr-always-fresh";
168
- cacheHeaders: boolean;
169
- transients: boolean;
170
- };
171
- serverless: {
172
- isr: boolean;
173
- dataCache: "none" | "in-memory" | "kv";
174
- };
175
- pageDataTTL: number;
176
- appDataTTL: number;
177
- queryHooksTTL: number;
178
- }>;
179
165
  legacyMetadata: boolean;
180
166
  legacyStitches: boolean;
181
167
  serverless: {
182
- plugins: "proxy" | "remote";
183
168
  enabled: boolean;
184
169
  uploads: "proxy" | "remote";
185
- admin: "hide" | "proxy";
170
+ plugins: "proxy" | "remote";
171
+ admin: "proxy" | "hide";
186
172
  originProtection: {
187
173
  requireLogin: boolean;
188
174
  };
189
175
  themeAssets: string[];
190
176
  endpoints: Record<string, string>;
191
177
  csp: {
192
- nonce: boolean;
193
178
  enabled: boolean;
194
179
  autoDetect: boolean;
180
+ nonce: boolean;
195
181
  values?: Record<string, string[]> | undefined;
196
182
  commonOrigins?: string[] | undefined;
197
183
  };
@@ -199,23 +185,37 @@ export declare const EDConfigSchema: z.ZodObject<{
199
185
  origins?: string[] | undefined;
200
186
  } | undefined;
201
187
  };
202
- devUI: "disabled" | "enabled";
188
+ cache: Record<string, {
189
+ serverless: {
190
+ isr: boolean;
191
+ dataCache: "in-memory" | "kv" | "none";
192
+ };
193
+ wordpress: {
194
+ cacheHeaders: boolean;
195
+ transients: boolean;
196
+ strategy?: "always" | "ssr-always-fresh" | undefined;
197
+ };
198
+ pageDataTTL: number;
199
+ appDataTTL: number;
200
+ queryHooksTTL: number;
201
+ }>;
202
+ devUI: "enabled" | "disabled";
203
203
  $schema?: string | undefined;
204
204
  trackers?: ({
205
- id: string;
206
205
  provider: "ga4";
207
- } | {
208
206
  id: string;
207
+ } | {
209
208
  provider: "gtm";
209
+ id: string;
210
210
  })[] | undefined;
211
211
  }, {
212
212
  version: "1" | "2";
213
213
  serverless: {
214
214
  uploads: "proxy" | "remote";
215
215
  endpoints: Record<string, string>;
216
- plugins?: "proxy" | "remote" | undefined;
217
216
  enabled?: boolean | undefined;
218
- admin?: "hide" | "proxy" | undefined;
217
+ plugins?: "proxy" | "remote" | undefined;
218
+ admin?: "proxy" | "hide" | undefined;
219
219
  originProtection?: {
220
220
  requireLogin?: boolean | undefined;
221
221
  } | undefined;
@@ -226,36 +226,36 @@ export declare const EDConfigSchema: z.ZodObject<{
226
226
  csp?: {
227
227
  enabled: boolean;
228
228
  values?: Record<string, string[]> | undefined;
229
- nonce?: boolean | undefined;
230
229
  autoDetect?: boolean | undefined;
230
+ nonce?: boolean | undefined;
231
231
  commonOrigins?: string[] | undefined;
232
232
  } | undefined;
233
233
  };
234
+ $schema?: string | undefined;
235
+ legacyMetadata?: boolean | undefined;
236
+ legacyStitches?: boolean | undefined;
237
+ trackers?: ({
238
+ provider: "ga4";
239
+ id: string;
240
+ } | {
241
+ provider: "gtm";
242
+ id: string;
243
+ })[] | undefined;
234
244
  cache?: Record<string, {
245
+ serverless?: {
246
+ isr?: boolean | undefined;
247
+ dataCache?: "in-memory" | "kv" | "none" | undefined;
248
+ } | undefined;
235
249
  wordpress?: {
236
- strategy: "always" | "ssr-always-fresh";
250
+ strategy?: "always" | "ssr-always-fresh" | undefined;
237
251
  cacheHeaders?: boolean | undefined;
238
252
  transients?: boolean | undefined;
239
253
  } | undefined;
240
- serverless?: {
241
- isr?: boolean | undefined;
242
- dataCache?: "none" | "in-memory" | "kv" | undefined;
243
- } | undefined;
244
254
  pageDataTTL?: number | undefined;
245
255
  appDataTTL?: number | undefined;
246
256
  queryHooksTTL?: number | undefined;
247
257
  }> | undefined;
248
- $schema?: string | undefined;
249
- legacyMetadata?: boolean | undefined;
250
- legacyStitches?: boolean | undefined;
251
- trackers?: ({
252
- id: string;
253
- provider: "ga4";
254
- } | {
255
- id: string;
256
- provider: "gtm";
257
- })[] | undefined;
258
- devUI?: "disabled" | "enabled" | undefined;
258
+ devUI?: "enabled" | "disabled" | undefined;
259
259
  }>;
260
260
  export type EDConfig = z.infer<typeof EDConfigSchema>;
261
261
  export declare class Configurator {
package/dist/node/project/config.d.ts.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/node/project/config.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,OAAO,EAAE,OAAO,EAAyB,MAAM,cAAc,CAAA;AAE7D,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiJzB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAErD,qBAAa,YAAY;IAGI,OAAO,EAAE,OAAO;IAF3C,MAAM,CAAC,EAAE,QAAQ,CAAA;IAEjB,OAAO;WAEM,MAAM,CAAC,OAAO,EAAE,OAAO;IAM9B,IAAI;YAQI,kBAAkB;YAYlB,UAAU;IAiCxB,OAAO,CAAC,WAAW;IAOnB,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO;CAUzD"}
1
+ {"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/node/project/config.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,OAAO,EAAE,OAAO,EAAyB,MAAM,cAAc,CAAA;AAE7D,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoJzB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAErD,qBAAa,YAAY;IAGI,OAAO,EAAE,OAAO;IAF3C,MAAM,CAAC,EAAE,QAAQ,CAAA;IAEjB,OAAO;WAEM,MAAM,CAAC,OAAO,EAAE,OAAO;IAM9B,IAAI;YAQI,kBAAkB;YAYlB,UAAU;IAiCxB,OAAO,CAAC,WAAW;IAOnB,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO;CAUzD"}
package/dist/node/project/config.js CHANGED
@@ -96,7 +96,10 @@ export const EDConfigSchema = z.object({
96
96
  .record(z.object({
97
97
  wordpress: z
98
98
  .object({
99
- strategy: z.enum(["always", "ssr-always-fresh"]),
99
+ strategy: z
100
+ .enum(["always", "ssr-always-fresh"])
101
+ .optional()
102
+ .describe("Deprecated. Use cacheHeaders/transients instead."),
100
103
  cacheHeaders: z.boolean().default(true).describe("Whether to add caching headers to data requests."),
101
104
  transients: z.boolean().default(true).describe("Whether to cache within transients."),
102
105
  })
package/dist/node/types/block-type.d.ts CHANGED
@@ -39,37 +39,37 @@ export declare const BlockMetaSchema: z.ZodObject<{
39
39
  label: z.ZodString;
40
40
  isDefault: z.ZodOptional<z.ZodBoolean>;
41
41
  }, "strip", z.ZodTypeAny, {
42
- label: string;
43
42
  name: string;
43
+ label: string;
44
44
  isDefault?: boolean | undefined;
45
45
  }, {
46
- label: string;
47
46
  name: string;
47
+ label: string;
48
48
  isDefault?: boolean | undefined;
49
49
  }>, "many">>;
50
50
  lazyLoad: z.ZodOptional<z.ZodBoolean>;
51
51
  }, "strip", z.ZodTypeAny, {
52
- title: string;
53
- mode: "both" | "edit" | "preview";
54
- slug: string;
55
- tags: string[];
56
- flags: Record<string, any>;
57
- category: string;
58
- parent: string[];
59
- inserter: boolean;
52
+ cache: boolean;
60
53
  acfName: string;
61
54
  fileName: string;
55
+ slug: string;
62
56
  graphqlFieldName: string;
57
+ title: string;
58
+ category: string;
63
59
  types: string[];
60
+ mode: "preview" | "edit" | "both";
61
+ tags: string[];
62
+ flags: Record<string, any>;
64
63
  childTags: string[];
65
64
  childBlocks: string[];
65
+ parent: string[];
66
66
  ancestors: string[];
67
67
  dynamic: boolean;
68
- cache: boolean;
69
68
  allowMultiple: boolean;
70
- frontendMode: "hidden" | "default" | "childrenOnly";
71
- icon?: string | undefined;
69
+ frontendMode: "default" | "hidden" | "childrenOnly";
70
+ inserter: boolean;
72
71
  description?: string | undefined;
72
+ icon?: string | undefined;
73
73
  keywords?: string | string[] | undefined;
74
74
  templates?: string[] | null | undefined;
75
75
  postMetaBlock?: {
@@ -77,42 +77,42 @@ export declare const BlockMetaSchema: z.ZodObject<{
77
77
  fieldName: string;
78
78
  } | undefined;
79
79
  blockStyles?: {
80
- label: string;
81
80
  name: string;
81
+ label: string;
82
82
  isDefault?: boolean | undefined;
83
83
  }[] | undefined;
84
84
  lazyLoad?: boolean | undefined;
85
85
  }, {
86
- title: string;
87
- slug: string;
88
86
  acfName: string;
89
87
  fileName: string;
88
+ slug: string;
90
89
  graphqlFieldName: string;
90
+ title: string;
91
91
  types: string[];
92
- mode?: "both" | "edit" | "preview" | undefined;
93
- tags?: string[] | undefined;
94
- flags?: Record<string, any> | undefined;
95
- icon?: string | undefined;
96
- category?: string | undefined;
92
+ cache?: boolean | undefined;
97
93
  description?: string | undefined;
94
+ category?: string | undefined;
95
+ icon?: string | undefined;
98
96
  keywords?: string | string[] | undefined;
99
- parent?: string[] | undefined;
100
- inserter?: boolean | undefined;
101
97
  templates?: string[] | null | undefined;
98
+ mode?: "preview" | "edit" | "both" | undefined;
99
+ tags?: string[] | undefined;
100
+ flags?: Record<string, any> | undefined;
102
101
  childTags?: string[] | undefined;
103
102
  childBlocks?: string[] | undefined;
103
+ parent?: string[] | undefined;
104
104
  ancestors?: string[] | undefined;
105
105
  dynamic?: boolean | undefined;
106
- cache?: boolean | undefined;
107
106
  allowMultiple?: boolean | undefined;
108
107
  postMetaBlock?: {
109
108
  postTypes: string[];
110
109
  fieldName: string;
111
110
  } | undefined;
112
- frontendMode?: "hidden" | "default" | "childrenOnly" | undefined;
111
+ frontendMode?: "default" | "hidden" | "childrenOnly" | undefined;
112
+ inserter?: boolean | undefined;
113
113
  blockStyles?: {
114
- label: string;
115
114
  name: string;
115
+ label: string;
116
116
  isDefault?: boolean | undefined;
117
117
  }[] | undefined;
118
118
  lazyLoad?: boolean | undefined;
package/dist/node/types/view-type.d.ts CHANGED
@@ -9,21 +9,21 @@ export declare const ViewMetaSchema: z.ZodObject<{
9
9
  routePattern: z.ZodOptional<z.ZodString>;
10
10
  postType: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
11
11
  }, "strip", z.ZodTypeAny, {
12
- title: string;
13
- slug: string;
14
- fileName: string;
15
12
  cache: boolean;
13
+ fileName: string;
14
+ slug: string;
15
+ title: string;
16
16
  isCustomTemplate: boolean;
17
- postType?: string[] | undefined;
18
17
  routePattern?: string | undefined;
18
+ postType?: string[] | undefined;
19
19
  }, {
20
- title: string;
21
- slug: string;
22
20
  fileName: string;
23
- postType?: string[] | undefined;
21
+ slug: string;
22
+ title: string;
24
23
  cache?: boolean | undefined;
25
24
  isCustomTemplate?: boolean | undefined;
26
25
  routePattern?: string | undefined;
26
+ postType?: string[] | undefined;
27
27
  }>;
28
28
  export type ViewMetadata = z.infer<typeof ViewMetaSchema>;
29
29
  export type ViewMetadataConstructor = z.input<typeof ViewMetaSchema>;
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "eddev",
3
- "version": "2.0.0-beta.222",
3
+ "version": "2.0.0-beta.223",
4
4
  "description": "",
5
5
  "main": "index.js",
6
6
  "type": "module",