@gigadrive/network-config 2.1.2 → 3.0.1

package/dist/index.d.mts

@@ -1,10 +1,7 @@
-declare const ALLOWED_CONFIG_NAMES: string[];
-/**
- * Finds a config file in the project folder.
- * @param projectFolder The folder to search for a config file in.
- * @returns The path to the config file, or null if no config file is found.
- */
-declare const findConfig: (projectFolder: string) => string | null;
+import { FileSystem, Path } from '@effect/platform';
+import { Schema, Effect, Layer } from 'effect';
+import * as _effect_platform_Path from '@effect/platform/Path';
+import * as _effect_platform_FileSystem from '@effect/platform/FileSystem';
 
 declare const REGION_DEFINITIONS: readonly ["us-east-1", "us-east-2", "us-west-1", "us-west-2", "ap-south-1", "ap-northeast-3", "ap-northeast-2", "ap-southeast-1", "ap-southeast-2", "ap-northeast-1", "ca-central-1", "eu-central-1", "eu-west-1", "eu-west-2", "eu-west-3", "eu-north-1", "sa-east-1"];
 type Region = (typeof REGION_DEFINITIONS)[number];
@@ -80,6 +77,13 @@ interface NormalizedConfig {
          */
         fileWhitelist?: string[];
     };
+    /**
+     * Glob or regex patterns for files to exclude from the deployment archive.
+     * Sourced from framework auto-detection (e.g. `tests/`, `node_modules/`) or
+     * user config. Patterns are matched via minimatch and RegExp against relative
+     * paths in the project directory.
+     */
+    excludeFiles?: string[];
     /**
      * Warning codes to be printed to the output during deployment.
      */
@@ -159,14 +163,428 @@ type NormalizedConfigRouteMatchRequirements = [] | [
     }
 ];
 
+declare const ManifestNotFoundError_base: Schema.TaggedErrorClass<ManifestNotFoundError, "ManifestNotFoundError", {
+    readonly _tag: Schema.tag<"ManifestNotFoundError">;
+} & {
+    message: typeof Schema.String;
+    filePath: typeof Schema.String;
+}>;
+declare class ManifestNotFoundError extends ManifestNotFoundError_base {
+}
+declare const ManifestReadError_base: Schema.TaggedErrorClass<ManifestReadError, "ManifestReadError", {
+    readonly _tag: Schema.tag<"ManifestReadError">;
+} & {
+    message: typeof Schema.String;
+    filePath: typeof Schema.String;
+}>;
+declare class ManifestReadError extends ManifestReadError_base {
+}
+declare const ManifestParseError_base: Schema.TaggedErrorClass<ManifestParseError, "ManifestParseError", {
+    readonly _tag: Schema.tag<"ManifestParseError">;
+} & {
+    message: typeof Schema.String;
+    filePath: typeof Schema.String;
+}>;
+declare class ManifestParseError extends ManifestParseError_base {
+}
+declare const FrameworkNotDetectedError_base: Schema.TaggedErrorClass<FrameworkNotDetectedError, "FrameworkNotDetectedError", {
+    readonly _tag: Schema.tag<"FrameworkNotDetectedError">;
+} & {
+    message: typeof Schema.String;
+    directory: typeof Schema.String;
+}>;
+declare class FrameworkNotDetectedError extends FrameworkNotDetectedError_base {
+}
+interface FrameworkDetectionItem {
+    /** Check manifest dependencies for this package (routed by framework language) */
+    matchPackage?: string;
+    /** Check if this file exists (relative to project root) */
+    path?: string;
+    /** If path is set, also check file content matches this regex */
+    matchContent?: string;
+}
+type FrameworkLanguage = 'node' | 'php';
+type PackageManager = 'npm' | 'yarn' | 'pnpm' | 'bun' | 'composer';
+interface FrameworkDefinition {
+    slug: string;
+    name: string;
+    language: FrameworkLanguage;
+    /** ALL items must match for the framework to be detected */
+    detectors: FrameworkDetectionItem[];
+    /** Higher = higher priority (specific frameworks beat generic ones) */
+    priority: number;
+    /** Generates deployment defaults for this framework */
+    getDefaultConfig: (packageManager: PackageManager) => FrameworkDefaultConfig;
+}
+interface FrameworkDefaultConfig {
+    runtime: Runtime;
+    memory: number;
+    maxDuration: number;
+    streaming: boolean;
+    /** Overrides the auto-generated install command (e.g. for custom composer flags) */
+    installCommand?: string;
+    /** Build commands (install command is auto-prepended by generateConfig) */
+    commands: string[];
+    entrypoint?: string;
+    assetsDir?: string;
+    populateAssetCache?: boolean;
+    routes: Array<{
+        source: string;
+        destination: string;
+    }>;
+    environmentVariables: Record<string, string>;
+    symlinks?: Record<string, string>;
+    excludeFiles?: string[];
+}
+interface DetectionResult {
+    framework: FrameworkDefinition;
+    packageManager: PackageManager;
+    config: NormalizedConfig;
+}
+
+/**
+ * Detects the framework used in a project by checking framework definitions
+ * against the project's dependencies and file structure.
+ *
+ * Framework definitions are checked in priority order (highest first).
+ * All detectors for a framework must match for it to be selected.
+ *
+ * @param projectFolder - Absolute path to the project root
+ * @returns DetectionResult with framework, package manager, and generated config
+ */
+declare const detectFramework: (projectFolder: string) => Effect.Effect<DetectionResult, ManifestReadError | ManifestParseError | FrameworkNotDetectedError, FileSystem.FileSystem | Path.Path>;
+
+/**
+ * Detects the package manager by checking for lockfiles in the project folder.
+ * Falls back to `npm` if no lockfile is found.
+ *
+ * @param projectFolder - Absolute path to the project root
+ * @returns The detected package manager
+ */
+declare const detectPackageManager: (projectFolder: string) => Effect.Effect<PackageManager, never, FileSystem.FileSystem | Path.Path>;
+
+/**
+ * All supported framework definitions, sorted by priority descending.
+ * Higher priority frameworks are checked first during detection.
+ */
+declare const FRAMEWORK_DEFINITIONS: FrameworkDefinition[];
+
+/**
+ * Generates a NormalizedConfig from a framework definition and detected package manager.
+ * Prepends the install command and builds a complete deployment configuration.
+ *
+ * @param framework - The detected framework definition
+ * @param packageManager - The detected package manager
+ * @returns A complete NormalizedConfig with framework defaults
+ */
+declare const generateConfig: (framework: FrameworkDefinition, packageManager: PackageManager) => Effect.Effect<NormalizedConfig, never, never>;
+
+/**
+ * Merges framework defaults with a user-provided config.
+ * User config always takes precedence; framework defaults fill gaps.
+ *
+ * - commands: use user's if non-empty, otherwise framework's
+ * - entrypoints: use user's if non-empty, otherwise framework's
+ * - routes: use user's if non-empty, otherwise framework's
+ * - assets: use user's if defined with paths, otherwise framework's
+ * - excludeFiles: use user's if non-empty, otherwise framework's
+ * - regions: always use user's (always populated from parsing)
+ * - environmentVariables: deep merge (framework base, user overrides)
+ * - services: always use user's (frameworks don't define services)
+ * - warnings/errors: concatenate both
+ *
+ * @param userConfig - The config parsed from the user's config file
+ * @param frameworkConfig - The config generated from framework detection
+ * @returns The merged config
+ */
+declare const mergeWithFrameworkDefaults: (userConfig: NormalizedConfig, frameworkConfig: NormalizedConfig) => Effect.Effect<NormalizedConfig, never, never>;
+
+/**
+ * Reads dependency names from the appropriate manifest file for a language.
+ * Returns a set of all dependency names (production + dev).
+ *
+ * If the manifest file does not exist, returns an empty set (graceful).
+ * If the file exists but cannot be read (`ManifestReadError`) or parsed
+ * (`ManifestParseError`), the error propagates — this indicates a real
+ * problem the user should know about.
+ *
+ * @param projectFolder - Absolute path to the project root
+ * @param language - The framework language to determine which manifest to read
+ * @returns A set of dependency package names
+ */
+declare const readDependencies: (projectFolder: string, language: FrameworkLanguage) => Effect.Effect<Set<string>, ManifestReadError | ManifestParseError, FileSystem.FileSystem | Path.Path>;
+
+declare const ConfigFileNotFoundError_base: Schema.TaggedErrorClass<ConfigFileNotFoundError, "ConfigFileNotFoundError", {
+    readonly _tag: Schema.tag<"ConfigFileNotFoundError">;
+} & {
+    message: typeof Schema.String;
+    filePath: typeof Schema.String;
+}>;
+declare class ConfigFileNotFoundError extends ConfigFileNotFoundError_base {
+}
+declare const ConfigFileEmptyError_base: Schema.TaggedErrorClass<ConfigFileEmptyError, "ConfigFileEmptyError", {
+    readonly _tag: Schema.tag<"ConfigFileEmptyError">;
+} & {
+    message: typeof Schema.String;
+    filePath: typeof Schema.String;
+}>;
+declare class ConfigFileEmptyError extends ConfigFileEmptyError_base {
+}
+declare const ConfigFileParseError_base: Schema.TaggedErrorClass<ConfigFileParseError, "ConfigFileParseError", {
+    readonly _tag: Schema.tag<"ConfigFileParseError">;
+} & {
+    message: typeof Schema.String;
+    filePath: typeof Schema.String;
+    cause: Schema.optional<typeof Schema.String>;
+}>;
+declare class ConfigFileParseError extends ConfigFileParseError_base {
+}
+declare const ConfigVersionError_base: Schema.TaggedErrorClass<ConfigVersionError, "ConfigVersionError", {
+    readonly _tag: Schema.tag<"ConfigVersionError">;
+} & {
+    message: typeof Schema.String;
+    filePath: typeof Schema.String;
+    version: Schema.optional<typeof Schema.Number>;
+}>;
+declare class ConfigVersionError extends ConfigVersionError_base {
+}
+declare const ConfigSchemaValidationError_base: Schema.TaggedErrorClass<ConfigSchemaValidationError, "ConfigSchemaValidationError", {
+    readonly _tag: Schema.tag<"ConfigSchemaValidationError">;
+} & {
+    message: typeof Schema.String;
+    filePath: typeof Schema.String;
+    validationErrors: Schema.Array$<typeof Schema.String>;
+}>;
+declare class ConfigSchemaValidationError extends ConfigSchemaValidationError_base {
+}
+declare const FunctionConfigError_base: Schema.TaggedErrorClass<FunctionConfigError, "FunctionConfigError", {
+    readonly _tag: Schema.tag<"FunctionConfigError">;
+} & {
+    message: typeof Schema.String;
+    functionPath: typeof Schema.String;
+}>;
+declare class FunctionConfigError extends FunctionConfigError_base {
+}
+
+/**
+ * Ensure a normalized config has no function files that are also defined as assets.
+ * For example, a file `public/index.php` should not be defined as an asset, when it is a function and `public` is an asset folder.
+ * @param config The normalized config to filter.
+ * @returns A promise that resolves to the filtered config.
+ */
+declare const filterFunctionsFromAssets: (config: NormalizedConfig) => NormalizedConfig;
+
+declare const ALLOWED_CONFIG_NAMES: readonly ["gigadrive.yaml", "gigadrive.yml", "nebula.yaml", "nebula.yml", "nebula.json"];
+declare const RawConfigReader_base: Effect.Service.Class<RawConfigReader, "RawConfigReader", {
+    readonly effect: Effect.Effect<{
+        findConfig: (projectFolder: string) => Effect.Effect<string | null, never, never>;
+        readRawConfig: (filePath: string, options?: {
+            disableVersionCheck?: boolean;
+        } | undefined) => Effect.Effect<Record<string, unknown>, ConfigFileNotFoundError | ConfigFileEmptyError | ConfigFileParseError | ConfigVersionError, never>;
+        readConfigFile: <T>(configFilePath: string) => Effect.Effect<T | null, ConfigFileEmptyError | ConfigFileParseError | ConfigVersionError, never>;
+    }, never, FileSystem.FileSystem | Path.Path>;
+}>;
+declare class RawConfigReader extends RawConfigReader_base {
+}
+
+declare const SchemaValidator_base: Effect.Service.Class<SchemaValidator, "SchemaValidator", {
+    readonly effect: Effect.Effect<{
+        validate: (config: Record<string, unknown>, schema: object, filePath: string) => Effect.Effect<undefined, ConfigSchemaValidationError, never>;
+    }, never, never>;
+}>;
+declare class SchemaValidator extends SchemaValidator_base {
+}
+
+interface ConfigV4 extends Config {
+    version: 4;
+    /**
+     * A list of presets to apply to the project. Each preset will be applied in order.
+     */
+    presets?: string[] | null;
+    /**
+     * The folder which holds the assets to be deployed to the edge. Defaults to none.
+     */
+    assets?: string | null;
+    /**
+     * If true, the assets will be cached at the edge during deployment. This may increase the deployment time, depending on the size of the assets. Defaults to false.
+     */
+    populateAssetCache?: boolean | null;
+    /**
+     * The regions to which the project will be deployed. Use "global" to deploy to all regions. More regions will incur higher costs.
+     */
+    regions?: string[] | null;
+    /**
+     * The commands to run to build the project. For example, `bun install` or `npm install`.
+     */
+    build_commands?: string[] | null;
+    /**
+     * The serverless functions to deploy.
+     */
+    functions?: {
+        /**
+         * The pattern to match the file path of the function. May be a glob pattern or a regular expression.
+         */
+        [pattern: string]: ConfigV4FunctionSettings;
+    } | null;
+    /**
+     * A list of route definitions.
+     *
+     * @maxItems 1024
+     */
+    routes?: {
+        /**
+         * A pattern that matches each incoming pathname (excluding querystring).
+         */
+        source: string;
+        /**
+         * An absolute pathname to an existing resource or an external URL.
+         */
+        destination: string;
+        /**
+         * An array of requirements that are needed to match
+         *
+         * @maxItems 16
+         */
+        has?: NormalizedConfigRouteMatchRequirements;
+        /**
+         * An array of requirements that are needed to match
+         *
+         * @maxItems 16
+         */
+        missing?: NormalizedConfigRouteMatchRequirements;
+        /**
+         * An optional integer to override the status code of the response.
+         */
+        statusCode?: number;
+        /**
+         * An optional boolean to force a redirect response.
+         */
+        redirect?: boolean;
+        /**
+         * The HTTP methods to match for the route. Defaults to all methods.
+         */
+        methods?: NormalizedConfigRouteMethod[];
+        /**
+         * Additional headers to add to the response.
+         */
+        headers?: {
+            [k: string]: string;
+        };
+    }[] | null;
+    /**
+     * Additional environment variables to set during runtime and build.
+     */
+    env: Record<string, string>;
+    /**
+     * Optionally, specify additional services like databases to deploy.
+     */
+    services?: {
+        [type in NormalizedConfigServiceType]?: ConfigV4Service | null;
+    };
+}
+interface ConfigV4Service {
+}
+interface ConfigV4FunctionSettings {
+    /**
+     * The memory limit for the function in MB.
+     */
+    memory?: number;
+    /**
+     * The maximum duration of the function in seconds. May not be higher than 15 minutes.
+     */
+    max_duration?: number;
+    /**
+     * The runtime to use for the function.
+     */
+    runtime?: Runtime;
+    /**
+     * Use to create symlinks on the final function. This is useful for applications that require use of the file system, since serverless functions are ephemeral and have read-only file systems, except for /tmp.
+     */
+    symlinks?: {
+        /**
+         * Left side is where the symlink will be created, right side is the target path.
+         */
+        [path: string]: string;
+    };
+    /**
+     * A glob pattern to match files that should be excluded from your Serverless Function. If you’re using a Community Runtime, the behavior might vary.
+     */
+    excludeFiles?: string | string[];
+    /**
+     * A glob pattern to match files that should be included in your Serverless Function. If you’re using a Community Runtime, the behavior might vary.
+     */
+    includeFiles?: string | string[];
+    /**
+     * Optionally, provide a schedule to run the function on periodically. Examples: `rate(1 hour)`, `rate(1 day)`, `cron(0 12 * * *)`.
+     */
+    schedule?: string;
+}
+
+/**
+ * Resolves merged function settings for a given path by iterating all function
+ * patterns in the config. Later patterns override earlier ones.
+ *
+ * @returns The merged settings, or undefined when no pattern matches the path.
+ */
+declare const getFunctionSettings: (path: string, config: ConfigV4) => ConfigV4FunctionSettings | undefined;
+declare const V4ConfigParser_base: Effect.Service.Class<V4ConfigParser, "V4ConfigParser", {
+    readonly accessors: true;
+    readonly effect: Effect.Effect<{
+        /**
+         * Parses a ConfigV4 into a NormalizedConfig.
+         *
+         * @param config - The raw V4 config object
+         * @param projectFolder - Absolute path to the project root
+         */
+        parse: (config: ConfigV4, projectFolder: string) => Effect.Effect<NormalizedConfig, FunctionConfigError, FileSystem.FileSystem | Path.Path>;
+    }, never, never>;
+}>;
+declare class V4ConfigParser extends V4ConfigParser_base {
+}
+
+declare const VercelBuildOutputParser_base: Effect.Service.Class<VercelBuildOutputParser, "VercelBuildOutputParser", {
+    readonly effect: Effect.Effect<{
+        parse: (parseResult: NormalizedConfig, projectFolder: string) => Effect.Effect<NormalizedConfig, ConfigFileEmptyError | ConfigFileParseError | ConfigVersionError, _effect_platform_FileSystem.FileSystem | Path.Path>;
+    }, never, Path.Path | RawConfigReader>;
+}>;
+declare class VercelBuildOutputParser extends VercelBuildOutputParser_base {
+}
+
 interface Config {
     version: number;
     env?: Record<string, string>;
 }
-declare const parseConfig: (filePath: string, projectFolder: string) => Promise<NormalizedConfig>;
+/**
+ * Parses a config file at the given path and validates it against the appropriate
+ * JSON Schema, returning a NormalizedConfig **without** post-processing.
+ *
+ * Use {@link parseConfig} when you also want Vercel BOv3 merging, empty-deployment
+ * checks, and function/asset deduplication applied automatically.
+ *
+ * @param filePath - Absolute path to the config file
+ * @param projectFolder - Absolute path to the project root
+ */
+declare const parseConfigRaw: (filePath: string, projectFolder: string) => Effect.Effect<NormalizedConfig, ConfigFileNotFoundError | ConfigFileEmptyError | ConfigFileParseError | ConfigVersionError | ConfigSchemaValidationError | FunctionConfigError, _effect_platform_FileSystem.FileSystem | _effect_platform_Path.Path | RawConfigReader | SchemaValidator | V4ConfigParser>;
+/**
+ * Parses a config file at the given path, validates it against the appropriate
+ * JSON Schema, converts it to a NormalizedConfig, and applies post-processing.
+ *
+ * @param filePath - Absolute path to the config file
+ * @param projectFolder - Absolute path to the project root
+ */
+declare const parseConfig: (filePath: string, projectFolder: string) => Effect.Effect<NormalizedConfig, ConfigFileNotFoundError | ConfigFileEmptyError | ConfigFileParseError | ConfigVersionError | ConfigSchemaValidationError | FunctionConfigError, _effect_platform_FileSystem.FileSystem | _effect_platform_Path.Path | RawConfigReader | SchemaValidator | V4ConfigParser | VercelBuildOutputParser>;
+/**
+ * Applies post-processing transformers to a NormalizedConfig:
+ * - Vercel Build Output v3 (merges functions/routes from .vercel/output if present)
+ * - Empty deployment validation
+ * - Filter functions from assets
+ *
+ * @param config - The parsed NormalizedConfig
+ * @param projectFolder - Absolute path to the project root
+ * @returns The post-processed NormalizedConfig
+ */
+declare const postProcessConfig: (config: NormalizedConfig, projectFolder: string) => Effect.Effect<NormalizedConfig, ConfigFileEmptyError | ConfigFileParseError | ConfigVersionError, _effect_platform_FileSystem.FileSystem | _effect_platform_Path.Path | VercelBuildOutputParser>;
 
-declare const parseRawConfig: (filePath: string, { disableVersionCheck }?: {
-    disableVersionCheck?: boolean;
-}) => Promise<Record<string, unknown>>;
+declare const NetworkConfigLive: Layer.Layer<RawConfigReader | SchemaValidator | V4ConfigParser | VercelBuildOutputParser, never, _effect_platform_FileSystem.FileSystem | _effect_platform_Path.Path>;
 
-export { ALLOWED_CONFIG_NAMES, AVAILABLE_REGIONS, AVAILABLE_RUNTIMES, type Config, type FilePathMap, type NeonAWSRegion, type NormalizedConfig, type NormalizedConfigEntrypoint, type NormalizedConfigRoute, type NormalizedConfigRouteHandler, type NormalizedConfigRouteMatchRequirements, type NormalizedConfigRouteMethod, type NormalizedConfigService, type NormalizedConfigServicePostgres, type NormalizedConfigServiceRedis, type NormalizedConfigServiceType, type Region, type Runtime, type UpstashAWSRegion, findConfig, parseConfig, parseRawConfig };
+export { ALLOWED_CONFIG_NAMES, AVAILABLE_REGIONS, AVAILABLE_RUNTIMES, type Config, ConfigFileEmptyError, ConfigFileNotFoundError, ConfigFileParseError, ConfigSchemaValidationError, ConfigVersionError, type DetectionResult, FRAMEWORK_DEFINITIONS, type FilePathMap, type FrameworkDefaultConfig, type FrameworkDefinition, type FrameworkDetectionItem, type FrameworkLanguage, FrameworkNotDetectedError, FunctionConfigError, ManifestNotFoundError, ManifestParseError, ManifestReadError, type NeonAWSRegion, NetworkConfigLive, type NormalizedConfig, type NormalizedConfigEntrypoint, type NormalizedConfigRoute, type NormalizedConfigRouteHandler, type NormalizedConfigRouteMatchRequirements, type NormalizedConfigRouteMethod, type NormalizedConfigService, type NormalizedConfigServicePostgres, type NormalizedConfigServiceRedis, type NormalizedConfigServiceType, type PackageManager, RawConfigReader, type Region, type Runtime, SchemaValidator, type UpstashAWSRegion, V4ConfigParser, VercelBuildOutputParser, detectFramework, detectPackageManager, filterFunctionsFromAssets, generateConfig, getFunctionSettings, mergeWithFrameworkDefaults, parseConfig, parseConfigRaw, postProcessConfig, readDependencies };