ngx-cloudflare 0.0.0-stage → 0.2.1

package/schematics/ng-add/wrangler-config.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WRANGLER_CONFIG_FILES = void 0;
+exports.parseWranglerConfig = parseWranglerConfig;
+exports.workerName = workerName;
+exports.hostsFromConfig = hostsFromConfig;
+exports.createWranglerConfig = createWranglerConfig;
+exports.repairWranglerConfig = repairWranglerConfig;
+exports.addAllowedHostsVar = addAllowedHostsVar;
+const jsonc_parser_1 = require("jsonc-parser");
+exports.WRANGLER_CONFIG_FILES = ['wrangler.jsonc', 'wrangler.json', 'wrangler.toml'];
+const DEFAULT_HOSTS = new Set(['localhost', '127.0.0.1', '*.workers.dev']);
+function parseWranglerConfig(text) {
+    const errors = [];
+    const config = (0, jsonc_parser_1.parse)(text, errors, { allowTrailingComma: true });
+    if (errors.length || typeof config !== 'object' || config === null) {
+        throw new Error('ngx-cloudflare: could not parse the wrangler config. Fix its syntax and run ng add again.');
+    }
+    return config;
+}
+function workerName(projectName) {
+    const name = projectName
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '')
+        .slice(0, 63)
+        .replace(/-$/, '');
+    return name || 'angular-app';
+}
+function routeHost(route) {
+    const pattern = typeof route === 'string' ? route : route.pattern;
+    if (!pattern) {
+        return null;
+    }
+    const host = pattern
+        .replace(/^https?:\/\//, '')
+        .split('/')[0]
+        .split(':')[0]
+        .toLowerCase();
+    return host || null;
+}
+function hostsFromConfig(config) {
+    const routes = [];
+    const collect = (scope) => {
+        if (scope.route) {
+            routes.push(scope.route);
+        }
+        routes.push(...(scope.routes ?? []));
+    };
+    collect(config);
+    for (const env of Object.values(config.env ?? {})) {
+        collect(env);
+    }
+    const hosts = [];
+    for (const route of routes) {
+        const host = routeHost(route);
+        if (host && !DEFAULT_HOSTS.has(host) && !hosts.includes(host)) {
+            hosts.push(host);
+        }
+    }
+    return hosts;
+}
+function createWranglerConfig(name, output, compatibilityDate) {
+    return `{
+  "$schema": "node_modules/wrangler/config-schema.json",
+  "name": "${name}",
+  "main": "${output.main}",
+  "compatibility_date": "${compatibilityDate}",
+  "assets": {
+    "binding": "ASSETS",
+    "directory": "${output.assets}"
+  },
+  "observability": {
+    "enabled": true
+  }
+}
+`;
+}
+function repairWranglerConfig(text, output) {
+    const config = parseWranglerConfig(text);
+    const changes = [];
+    const formatting = { formattingOptions: { insertSpaces: !text.includes('\n\t'), tabSize: 2 } };
+    let result = text;
+    const set = (path, value) => {
+        result = (0, jsonc_parser_1.applyEdits)(result, (0, jsonc_parser_1.modify)(result, path, value, formatting));
+    };
+    if (config.main !== output.main) {
+        set(['main'], output.main);
+        changes.push(config.main
+            ? `main: ${config.main} -> ${output.main}`
+            : `main: ${output.main} (was missing, so the app was deployed without server rendering)`);
+    }
+    if (config.assets?.directory !== output.assets) {
+        set(['assets', 'directory'], output.assets);
+        changes.push(`assets.directory: ${config.assets?.directory ?? '(none)'} -> ${output.assets}`);
+    }
+    if (!config.assets?.binding) {
+        set(['assets', 'binding'], 'ASSETS');
+        changes.push('assets.binding: ASSETS');
+    }
+    return { text: result, changes };
+}
+function addAllowedHostsVar(text, hosts) {
+    const config = parseWranglerConfig(text);
+    const current = config.vars?.['ALLOWED_HOSTS'];
+    const existing = typeof current === 'string' ? current.split(/[\s,]+/).filter(Boolean) : [];
+    const added = hosts.filter((host) => !existing.includes(host));
+    if (!added.length) {
+        return { text, added };
+    }
+    const formatting = { formattingOptions: { insertSpaces: !text.includes('\n\t'), tabSize: 2 } };
+    const value = [...existing, ...added].join(',');
+    return {
+        text: (0, jsonc_parser_1.applyEdits)(text, (0, jsonc_parser_1.modify)(text, ['vars', 'ALLOWED_HOSTS'], value, formatting)),
+        added,
+    };
+}

package/schematics/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/types/ngx-cloudflare-server.d.ts

@@ -0,0 +1,61 @@
+declare global {
+  namespace Cloudflare {
+    interface Env {}
+  }
+}
+export declare const CLOUDFLARE_CONTEXT_MARKER: unique symbol;
+export declare const DEFAULT_ALLOWED_HOSTS: readonly string[];
+export declare const DEFAULT_API_PREFIX = "/api/";
+export interface CloudflareExecutionContext {
+  waitUntil(promise: Promise<unknown>): void;
+  passThroughOnException(): void;
+}
+export type CloudflareRequestCf = Record<string, unknown>;
+export type CloudflareContextSource = 'workers' | 'platform-proxy';
+export interface CloudflarePlatform<Env = Cloudflare.Env, Cf = CloudflareRequestCf> {
+  readonly env: Env;
+  readonly ctx: CloudflareExecutionContext;
+  readonly cf: Cf | undefined;
+}
+export interface CloudflareContext<Env = Cloudflare.Env, Cf = CloudflareRequestCf> extends CloudflarePlatform<Env, Cf> {
+  readonly source: CloudflareContextSource;
+  readonly dispatch: (request: Request) => Promise<Response | null>;
+  readonly [CLOUDFLARE_CONTEXT_MARKER]: true;
+}
+export type ApiResult = Response | null | undefined;
+export type ApiHandler<Env = Cloudflare.Env> = (request: Request, env: Env, ctx: CloudflareExecutionContext) => ApiResult | Promise<ApiResult>;
+export type ApiOption<Env = Cloudflare.Env> = ApiHandler<Env> | {
+  fetch: ApiHandler<Env>;
+};
+export interface CloudflareHandlerOptions<Env = Cloudflare.Env> {
+  allowedHosts?: readonly string[];
+  api?: ApiOption<Env>;
+  apiPrefix?: string | false;
+  stripProxyHeaders?: boolean;
+}
+export type RenderFunction = (request: Request, context: CloudflareContext<any, any> | undefined) => Promise<Response | null>;
+export type DevPlatformLoader = () => Promise<CloudflarePlatform<any, any> | undefined> | undefined;
+export type CloudflareFetchHandler<Env = Cloudflare.Env> = (request: Request, env?: Env, ctx?: CloudflareExecutionContext) => Promise<Response>;
+export declare function isInProcessRequest(request: Request): boolean;
+export declare function isCloudflareContext(value: unknown): value is CloudflareContext<any, any>;
+export declare const ALLOWED_HOSTS_VAR = "ALLOWED_HOSTS";
+export declare function hostsFromEnv(env: unknown): string[];
+export declare function resolveAllowedHosts(extra?: readonly string[]): string[];
+export declare function isHostAllowed(hostname: string, allowedHosts: readonly string[]): boolean;
+export declare function hostRefusal(hostname: string): Response;
+export declare function isProxyHeader(name: string): boolean;
+export declare function stripProxyHeaders(request: Request): Request;
+export declare function toApiHandler<Env>(api: ApiOption<Env> | undefined): ApiHandler<Env> | undefined;
+export declare function callInProcess<Env>(handler: ApiHandler<Env>, request: Request, env: Env, ctx: CloudflareExecutionContext): Promise<Response | null>;
+export declare function createCloudflareFetch<Env = Cloudflare.Env>(render: RenderFunction, options?: CloudflareHandlerOptions<Env>, loadDevPlatform?: DevPlatformLoader): CloudflareFetchHandler<Env>;
+export interface DevPlatformOptions {
+  configPath?: string;
+  environment?: string;
+  persist?: boolean | {
+    path: string;
+  };
+}
+export interface CloudflareRequestHandlerOptions<Env = Cloudflare.Env> extends CloudflareHandlerOptions<Env> {
+  devPlatform?: DevPlatformOptions | false;
+}
+export declare function createCloudflareRequestHandler<Env = Cloudflare.Env>(options?: CloudflareRequestHandlerOptions<Env>): CloudflareFetchHandler<Env>;

package/types/ngx-cloudflare-testing.d.ts

@@ -0,0 +1,16 @@
+import { EnvironmentProviders } from "@angular/core";
+import { ApiOption, CloudflareContext, CloudflareContextSource, CloudflareExecutionContext, CloudflareRequestCf } from "ngx-cloudflare/server";
+export interface CloudflareTestingOptions<Env = Cloudflare.Env, Cf = CloudflareRequestCf> {
+  env?: Partial<Env>;
+  cf?: Cf;
+  ctx?: Partial<CloudflareExecutionContext>;
+  url?: string;
+  api?: ApiOption<Env>;
+  source?: CloudflareContextSource;
+}
+export interface TestExecutionContext extends CloudflareExecutionContext {
+  readonly waitUntilPromises: Promise<unknown>[];
+}
+export declare function createTestExecutionContext(overrides?: Partial<CloudflareExecutionContext>): TestExecutionContext;
+export declare function createCloudflareTestContext<Env = Cloudflare.Env, Cf = CloudflareRequestCf>(options?: CloudflareTestingOptions<Env, Cf>): CloudflareContext<Env, Cf>;
+export declare function provideCloudflareTesting<Env = Cloudflare.Env, Cf = CloudflareRequestCf>(options?: CloudflareTestingOptions<Env, Cf>): EnvironmentProviders;

package/types/ngx-cloudflare.d.ts

@@ -0,0 +1,36 @@
+import { CloudflareContext, CloudflareContext as CloudflareContext$1, CloudflareContextSource, CloudflareExecutionContext, CloudflareExecutionContext as CloudflareExecutionContext$1, CloudflareRequestCf, CloudflareRequestCf as CloudflareRequestCf$1 } from "ngx-cloudflare/server";
+import * as i0 from "@angular/core";
+import { EnvironmentProviders } from "@angular/core";
+import { FetchBackend, HttpEvent, HttpRequest } from "@angular/common/http";
+import { Observable } from "rxjs";
+export interface InjectCloudflareOptions {
+  required?: boolean;
+}
+export declare function injectCloudflare<Env = Cloudflare.Env, Cf = CloudflareRequestCf$1>(options: {
+  required: true;
+}): CloudflareContext$1<Env, Cf>;
+export declare function injectCloudflare<Env = Cloudflare.Env, Cf = CloudflareRequestCf$1>(options?: InjectCloudflareOptions): CloudflareContext$1<Env, Cf> | null;
+export declare function injectEnv<Env = Cloudflare.Env>(options: {
+  required: true;
+}): Env;
+export declare function injectEnv<Env = Cloudflare.Env>(options?: InjectCloudflareOptions): Env | null;
+export declare function injectExecutionContext(options: {
+  required: true;
+}): CloudflareExecutionContext$1;
+export declare function injectExecutionContext(options?: InjectCloudflareOptions): CloudflareExecutionContext$1 | null;
+export declare function injectRequestCf<Cf = CloudflareRequestCf$1>(options: {
+  required: true;
+}): Cf;
+export declare function injectRequestCf<Cf = CloudflareRequestCf$1>(options?: InjectCloudflareOptions): Cf | null;
+export interface ProvideCloudflareOptions {
+  inProcessRequests?: boolean;
+}
+export declare function provideCloudflare(options?: ProvideCloudflareOptions): EnvironmentProviders;
+export declare class CloudflareFetchBackend extends FetchBackend {
+  private readonly cloudflare;
+  private readonly incoming;
+  handle(req: HttpRequest<unknown>): Observable<HttpEvent<unknown>>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<CloudflareFetchBackend, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export type { CloudflareContext, CloudflareContextSource, CloudflareExecutionContext, CloudflareRequestCf };