@uploadista/server 0.0.10 → 0.0.12

package/src/__tests__/backward-compatibility.test.ts

@@ -0,0 +1,285 @@
+/**
+ * Backward compatibility tests for deprecated exports.
+ *
+ * These tests verify that old import paths and deprecated APIs still work
+ * correctly, ensuring no breaking changes for existing code.
+ */
+
+import { describe, expect, it } from "vitest";
+
+// ============================================================================
+// Test Deprecated plugins-typing Module
+// ============================================================================
+
+describe("Deprecated plugins-typing module", () => {
+	it("should still be importable", async () => {
+		// Import from deprecated module - should not throw
+		const pluginsTyping = await import("../plugins-typing");
+
+		// Module should exist
+		expect(pluginsTyping).toBeDefined();
+		// All exports in plugins-typing are type-only, so we can't test runtime values
+	});
+
+	it("should export type-only deprecated types", () => {
+		// This test verifies at compile time that deprecated types are still exported
+		// Runtime verification is not possible for type-only exports
+		// Types to verify (compile-time only):
+		// - LayerSuccessUnion
+		// - FlowSuccess
+		// - FlowRequirementsOf
+		// - RequiredPluginsOf
+		// - PluginAssertion
+		expect(true).toBe(true); // Placeholder - types are tested at compile time
+	});
+});
+
+// ============================================================================
+// Test Deprecated createTypeSafeServer
+// ============================================================================
+
+describe("Deprecated createTypeSafeServer", () => {
+	it("should still be exported from core module", async () => {
+		const coreModule = await import("../core");
+
+		expect(coreModule).toHaveProperty("createTypeSafeServer");
+		expect(typeof coreModule.createTypeSafeServer).toBe("function");
+	});
+
+	it("should be exported from create-type-safe-server module", async () => {
+		const module = await import("../core/create-type-safe-server");
+
+		expect(module).toHaveProperty("createTypeSafeServer");
+		expect(typeof module.createTypeSafeServer).toBe("function");
+	});
+
+	it("should export helper functions", async () => {
+		const module = await import("../core/create-type-safe-server");
+
+		expect(module).toHaveProperty("defineFlow");
+		expect(module).toHaveProperty("defineSimpleFlow");
+		expect(typeof module.defineFlow).toBe("function");
+		expect(typeof module.defineSimpleFlow).toBe("function");
+	});
+});
+
+// ============================================================================
+// Test New Module Exports
+// ============================================================================
+
+describe("New module exports", () => {
+	it("should export runtime utilities from core module", async () => {
+		const coreModule = await import("../core");
+
+		// Runtime validation (these are actual runtime functions)
+		expect(coreModule).toHaveProperty("validatePluginRequirements");
+		expect(coreModule).toHaveProperty("formatPluginValidationError");
+		expect(coreModule).toHaveProperty("validatePluginRequirementsEffect");
+		expect(coreModule).toHaveProperty("validatePluginsOrThrow");
+
+		// Server creation
+		expect(coreModule).toHaveProperty("createUploadistaServer");
+
+		// Note: ExtractFlowPluginRequirements, InferFlowRequirements, ValidatePlugins,
+		// PluginServices, TypeSafeFlowFunction are type-only exports and cannot be
+		// tested at runtime. They are tested at compile time.
+	});
+
+	it("should export plugin validation utilities", async () => {
+		const validationModule = await import("../core/plugin-validation");
+
+		expect(validationModule).toHaveProperty("validatePluginRequirements");
+		expect(validationModule).toHaveProperty("formatPluginValidationError");
+		expect(validationModule).toHaveProperty(
+			"validatePluginRequirementsEffect",
+		);
+		expect(validationModule).toHaveProperty("validatePluginsOrThrow");
+		expect(validationModule).toHaveProperty("extractServiceIdentifiers");
+
+		// Verify they are functions
+		expect(typeof validationModule.validatePluginRequirements).toBe("function");
+		expect(typeof validationModule.formatPluginValidationError).toBe("function");
+		expect(typeof validationModule.validatePluginRequirementsEffect).toBe(
+			"function",
+		);
+		expect(typeof validationModule.validatePluginsOrThrow).toBe("function");
+		expect(typeof validationModule.extractServiceIdentifiers).toBe("function");
+	});
+
+	it("should export plugin types module", async () => {
+		const pluginTypesModule = await import("../core/plugin-types");
+
+		// Module should exist and be importable
+		expect(pluginTypesModule).toBeDefined();
+
+		// Note: All exports from plugin-types are type-only (TypeScript types)
+		// and cannot be tested at runtime. They include:
+		// - ExtractFlowPluginRequirements (type)
+		// - InferFlowRequirements (type)
+		// - ValidatePlugins (type)
+		// - PluginServices (type)
+		// - TypeSafeFlowFunction (type)
+		// These are tested at compile time, not runtime.
+	});
+});
+
+// ============================================================================
+// Test Import Path Compatibility
+// ============================================================================
+
+describe("Import path compatibility", () => {
+	it("should support importing from main core module", async () => {
+		const exports = await import("../core");
+
+		// Old APIs
+		expect(exports.createTypeSafeServer).toBeDefined();
+
+		// New APIs
+		expect(exports.createUploadistaServer).toBeDefined();
+		expect(exports.validatePluginRequirements).toBeDefined();
+
+		// Both should be functions
+		expect(typeof exports.createTypeSafeServer).toBe("function");
+		expect(typeof exports.createUploadistaServer).toBe("function");
+	});
+
+	it("should support importing deprecated module directly", async () => {
+		const exports = await import("../plugins-typing");
+
+		// Module should be importable
+		expect(exports).toBeDefined();
+		// All exports are type-only
+	});
+
+	it("should support importing new modules directly", async () => {
+		const pluginTypes = await import("../core/plugin-types");
+		const pluginValidation = await import("../core/plugin-validation");
+		const server = await import("../core/server");
+
+		// Modules should be importable
+		expect(pluginTypes).toBeDefined();
+		expect(pluginValidation.validatePluginRequirements).toBeDefined();
+		expect(server.createUploadistaServer).toBeDefined();
+	});
+});
+
+// ============================================================================
+// Test Helper Functions
+// ============================================================================
+
+describe("Helper functions compatibility", () => {
+	it("should support defineFlow helper", async () => {
+		const { defineFlow } = await import("../core/create-type-safe-server");
+		const { Effect } = await import("effect");
+
+		// Should be able to use defineFlow
+		const flow = defineFlow(() => Effect.succeed({} as any));
+
+		expect(typeof flow).toBe("function");
+	});
+
+	it("should support defineSimpleFlow helper", async () => {
+		const { defineSimpleFlow } = await import(
+			"../core/create-type-safe-server"
+		);
+		const { Effect } = await import("effect");
+
+		// Should be able to use defineSimpleFlow
+		const flow = defineSimpleFlow(() => Effect.succeed({} as any));
+
+		expect(typeof flow).toBe("function");
+	});
+
+	it("should have ExtractFlowPluginRequirements type available", () => {
+		// ExtractFlowPluginRequirements is a type-only export from plugin-types
+		// It cannot be tested at runtime, only at compile time
+		// This test serves as documentation that the type exists
+		expect(true).toBe(true);
+	});
+
+	it("should have InferFlowRequirements type available", () => {
+		// InferFlowRequirements is a type-only export from plugin-types
+		// It cannot be tested at runtime, only at compile time
+		// This test serves as documentation that the type exists
+		expect(true).toBe(true);
+	});
+});
+
+// ============================================================================
+// Test TypeScript Type Availability (Runtime Check)
+// ============================================================================
+
+describe("Type availability", () => {
+	it("should have TypeSafeServerConfig type available", async () => {
+		// This is a compile-time check that the type exists
+		// At runtime, we just verify the module exports
+		const module = await import("../core/create-type-safe-server");
+
+		expect(module).toBeDefined();
+		// Type would be checked at compile time
+	});
+
+	it("should have plugin validation types available", async () => {
+		const module = await import("../core/plugin-validation");
+
+		expect(module).toBeDefined();
+		// Types like PluginValidationResult would be checked at compile time
+	});
+
+	it("should have plugin types available", async () => {
+		const module = await import("../core/plugin-types");
+
+		expect(module).toBeDefined();
+		// Types like ValidatePlugins, PluginServices would be checked at compile time
+	});
+});
+
+// ============================================================================
+// Test Migration Scenarios
+// ============================================================================
+
+describe("Migration scenarios", () => {
+	it("should support old createTypeSafeServer imports", async () => {
+		// Old code pattern
+		const { createTypeSafeServer } = await import(
+			"../core/create-type-safe-server"
+		);
+
+		expect(createTypeSafeServer).toBeDefined();
+		expect(typeof createTypeSafeServer).toBe("function");
+	});
+
+	it("should support new createUploadistaServer imports", async () => {
+		// New code pattern
+		const { createUploadistaServer } = await import("../core/server");
+
+		expect(createUploadistaServer).toBeDefined();
+		expect(typeof createUploadistaServer).toBe("function");
+	});
+
+	it("should support old plugin typing imports", async () => {
+		// Old code pattern - module should be importable
+		const oldModule = await import("../plugins-typing");
+
+		expect(oldModule).toBeDefined();
+		// All exports are type-only (LayerSuccessUnion, FlowRequirementsOf, etc.)
+	});
+
+	it("should support new plugin typing imports", async () => {
+		// New code pattern - module should be importable
+		const newModule = await import("../core/plugin-types");
+
+		expect(newModule).toBeDefined();
+		// All exports are type-only (ExtractFlowPluginRequirements, ValidatePlugins, etc.)
+	});
+
+	it("should support importing both old and new modules", async () => {
+		// Both modules should be importable without conflicts
+		const oldModule = await import("../plugins-typing");
+		const newModule = await import("../core/plugin-types");
+
+		expect(oldModule).toBeDefined();
+		expect(newModule).toBeDefined();
+		// Type compatibility is tested at compile time
+	});
+});