@jay-framework/fullstack-component 0.9.0 → 0.11.0

package/dist/index.js

@@ -4,34 +4,52 @@ var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
-function serverError5xx(status) {
+function serverError5xx(status, message, details) {
   return {
     kind: "ServerError",
-    status
+    status,
+    message,
+    details
   };
 }
-function clientError4xx(status) {
+function clientError4xx(status, message, details) {
   return {
     kind: "ClientError",
-    status
+    status,
+    message,
+    details
   };
 }
-function notFound() {
-  return clientError4xx(404);
+function notFound(message, details) {
+  return clientError4xx(404, message, details);
+}
+function badRequest(message, details) {
+  return clientError4xx(400, message, details);
 }
-function redirect3xx(status, location) {
+function unauthorized(message, details) {
+  return clientError4xx(401, message, details);
+}
+function forbidden(message, details) {
+  return clientError4xx(403, message, details);
+}
+function redirect3xx(status, location, message) {
   return {
-    kind: "redirect",
+    kind: "Redirect",
     status,
-    location
+    location,
+    message
   };
 }
+function phaseOutput(rendered, carryForward) {
+  return { kind: "PhaseOutput", rendered, carryForward };
+}
 function partialRender(rendered, carryForward) {
-  return { kind: "PartialRender", rendered, carryForward };
+  return phaseOutput(rendered, carryForward);
 }
 function createJayService(name) {
   return Symbol(name);
 }
+const DYNAMIC_CONTRACT_SERVICE = createJayService("DynamicContract");
 class BuilderImplementation {
   constructor() {
     __publicField(this, "services", []);
@@ -72,12 +90,364 @@ class BuilderImplementation {
 function makeJayStackComponent() {
   return new BuilderImplementation();
 }
+class ContractGeneratorBuilderImpl {
+  constructor(serviceMarkers = []) {
+    __publicField(this, "serviceMarkers");
+    this.serviceMarkers = serviceMarkers;
+  }
+  withServices(...serviceMarkers) {
+    return new ContractGeneratorBuilderImpl(serviceMarkers);
+  }
+  generateWith(fn) {
+    return {
+      services: this.serviceMarkers,
+      generate: fn
+    };
+  }
+}
+function makeContractGenerator() {
+  return new ContractGeneratorBuilderImpl();
+}
+function isRenderPipeline(value) {
+  return value instanceof RenderPipeline;
+}
+function isErrorOutcome(value) {
+  return typeof value === "object" && value !== null && "kind" in value && (value.kind === "ServerError" || value.kind === "ClientError" || value.kind === "Redirect");
+}
+class RenderPipeline {
+  constructor(_value, _isSuccess) {
+    this._value = _value;
+    this._isSuccess = _isSuccess;
+  }
+  // =========================================================================
+  // Static Factory
+  // =========================================================================
+  /**
+   * Create a typed pipeline factory with target output types declared upfront.
+   * TypeScript validates that .toPhaseOutput() produces these types.
+   */
+  static for() {
+    return {
+      ok(value) {
+        return new RenderPipeline(value, true);
+      },
+      try(fn) {
+        try {
+          const result = fn();
+          if (result instanceof Promise) {
+            const wrappedPromise = result.catch((error) => {
+              throw { __pipelineError: true, error };
+            });
+            return new RenderPipeline(
+              wrappedPromise,
+              true
+            );
+          }
+          return new RenderPipeline(result, true);
+        } catch (error) {
+          return new RenderPipeline(
+            { __caughtError: error },
+            true
+          );
+        }
+      },
+      from(outcome) {
+        if (outcome.kind === "PhaseOutput") {
+          return new RenderPipeline(outcome.rendered, true);
+        }
+        return new RenderPipeline(outcome, false);
+      },
+      notFound(message, details) {
+        return new RenderPipeline(
+          notFound(message, details),
+          false
+        );
+      },
+      badRequest(message, details) {
+        return new RenderPipeline(
+          badRequest(message, details),
+          false
+        );
+      },
+      unauthorized(message, details) {
+        return new RenderPipeline(
+          unauthorized(message, details),
+          false
+        );
+      },
+      forbidden(message, details) {
+        return new RenderPipeline(
+          forbidden(message, details),
+          false
+        );
+      },
+      serverError(status, message, details) {
+        return new RenderPipeline(
+          serverError5xx(status, message, details),
+          false
+        );
+      },
+      clientError(status, message, details) {
+        return new RenderPipeline(
+          clientError4xx(status, message, details),
+          false
+        );
+      },
+      redirect(status, location) {
+        return new RenderPipeline(
+          redirect3xx(status, location),
+          false
+        );
+      }
+    };
+  }
+  // =========================================================================
+  // Transformation Methods
+  // =========================================================================
+  /**
+   * Transform the working value. Always returns RenderPipeline (sync).
+   *
+   * The mapping function can return:
+   * - U: Plain value
+   * - Promise<U>: Async value (resolved at toPhaseOutput)
+   * - RenderPipeline<U>: For conditional errors/branching
+   *
+   * Errors pass through unchanged.
+   */
+  map(fn) {
+    if (!this._isSuccess) {
+      return this;
+    }
+    if (this._value instanceof Promise) {
+      const chainedPromise = this._value.then((resolvedValue) => {
+        if (isRenderPipeline(resolvedValue)) {
+          return resolvedValue.map(fn)._value;
+        }
+        if (isErrorOutcome(resolvedValue)) {
+          return resolvedValue;
+        }
+        return fn(resolvedValue);
+      });
+      return new RenderPipeline(
+        chainedPromise,
+        true
+      );
+    }
+    if (isErrorOutcome(this._value)) {
+      return new RenderPipeline(this._value, false);
+    }
+    if (isRenderPipeline(this._value)) {
+      return this._value.map(fn);
+    }
+    const result = fn(this._value);
+    if (isRenderPipeline(result)) {
+      return result;
+    }
+    return new RenderPipeline(result, true);
+  }
+  /**
+   * Handle errors, potentially recovering to a success.
+   * The function receives the caught Error and can return a new pipeline.
+   */
+  recover(fn) {
+    if (!this._isSuccess && isErrorOutcome(this._value)) {
+      const error = new Error(
+        this._value.message || `${this._value.kind}: ${this._value.status}`
+      );
+      error.outcome = this._value;
+      return fn(error);
+    }
+    if (this._value instanceof Promise) {
+      const recoveredPromise = this._value.then((resolved) => {
+        if (isRenderPipeline(resolved)) {
+          return resolved.recover(fn)._value;
+        }
+        if (isErrorOutcome(resolved)) {
+          const error = new Error(
+            resolved.message || `${resolved.kind}: ${resolved.status}`
+          );
+          error.outcome = resolved;
+          return fn(error)._value;
+        }
+        return resolved;
+      }).catch((caught) => {
+        let actualError = caught;
+        if (typeof caught === "object" && caught !== null && "__pipelineError" in caught) {
+          actualError = caught.error;
+        }
+        const error = actualError instanceof Error ? actualError : new Error(String(actualError));
+        return fn(error)._value;
+      });
+      return new RenderPipeline(
+        recoveredPromise,
+        true
+      );
+    }
+    if (typeof this._value === "object" && this._value !== null && "__caughtError" in this._value) {
+      const caught = this._value.__caughtError;
+      const error = caught instanceof Error ? caught : new Error(String(caught));
+      return fn(error);
+    }
+    return this;
+  }
+  // =========================================================================
+  // Terminal Methods
+  // =========================================================================
+  /**
+   * Convert to final PhaseOutput. This is the ONLY async method.
+   * Resolves all pending promises and applies the final mapping.
+   */
+  async toPhaseOutput(fn) {
+    let resolvedValue;
+    if (this._value instanceof Promise) {
+      try {
+        resolvedValue = await this._value;
+      } catch (caught) {
+        let actualError = caught;
+        if (typeof caught === "object" && caught !== null && "__pipelineError" in caught) {
+          actualError = caught.error;
+        }
+        const message = actualError instanceof Error ? actualError.message : String(actualError);
+        return serverError5xx(500, message);
+      }
+    } else {
+      resolvedValue = this._value;
+    }
+    if (typeof resolvedValue === "object" && resolvedValue !== null && "__caughtError" in resolvedValue) {
+      const caught = resolvedValue.__caughtError;
+      const message = caught instanceof Error ? caught.message : String(caught);
+      return serverError5xx(500, message);
+    }
+    if (isRenderPipeline(resolvedValue)) {
+      return resolvedValue.toPhaseOutput(fn);
+    }
+    if (isErrorOutcome(resolvedValue)) {
+      return resolvedValue;
+    }
+    const { viewState, carryForward } = fn(resolvedValue);
+    return phaseOutput(viewState, carryForward);
+  }
+  // =========================================================================
+  // Utility Methods
+  // =========================================================================
+  /** Check if this pipeline is in a success state */
+  isOk() {
+    return this._isSuccess;
+  }
+  /** Check if this pipeline is in an error state */
+  isError() {
+    return !this._isSuccess;
+  }
+}
+class ActionError extends Error {
+  constructor(code, message) {
+    super(message);
+    __publicField(this, "name", "ActionError");
+    this.code = code;
+  }
+}
+class JayActionBuilderImpl {
+  constructor(_actionName, defaultMethod) {
+    __publicField(this, "_services", []);
+    __publicField(this, "_method");
+    __publicField(this, "_cacheOptions");
+    this._actionName = _actionName;
+    this._method = defaultMethod;
+  }
+  withServices(...services) {
+    this._services = services;
+    return this;
+  }
+  withMethod(method) {
+    this._method = method;
+    return this;
+  }
+  withCaching(options) {
+    this._cacheOptions = options ?? { maxAge: 60 };
+    return this;
+  }
+  withHandler(handler) {
+    const actionName = this._actionName;
+    const method = this._method;
+    const cacheOptions = this._cacheOptions;
+    const services = this._services;
+    const action = Object.assign(
+      (input) => handler(input, ...[]),
+      {
+        actionName,
+        method,
+        cacheOptions,
+        services,
+        handler,
+        _brand: "JayAction"
+      }
+    );
+    return action;
+  }
+}
+function makeJayAction(name) {
+  return new JayActionBuilderImpl(name, "POST");
+}
+function makeJayQuery(name) {
+  return new JayActionBuilderImpl(name, "GET");
+}
+function isJayAction(value) {
+  return typeof value === "function" && value._brand === "JayAction" && typeof value.actionName === "string";
+}
+function makeJayInit(key) {
+  const resolvedKey = key ?? "__JAY_INIT_KEY__";
+  return {
+    withServer(callback) {
+      const serverOnlyInit = {
+        __brand: "JayInit",
+        key: resolvedKey,
+        _serverInit: callback
+      };
+      return {
+        // JayInit properties (allows using as server-only init)
+        ...serverOnlyInit,
+        // Builder method to add client init
+        withClient(clientCallback) {
+          return {
+            __brand: "JayInit",
+            key: resolvedKey,
+            _serverInit: callback,
+            _clientInit: clientCallback
+          };
+        }
+      };
+    },
+    withClient(callback) {
+      return {
+        __brand: "JayInit",
+        key: resolvedKey,
+        _clientInit: callback
+      };
+    }
+  };
+}
+function isJayInit(obj) {
+  return typeof obj === "object" && obj !== null && "__brand" in obj && obj.__brand === "JayInit";
+}
 export {
+  ActionError,
+  DYNAMIC_CONTRACT_SERVICE,
+  RenderPipeline,
+  badRequest,
   clientError4xx,
   createJayService,
+  forbidden,
+  isJayAction,
+  isJayInit,
+  makeContractGenerator,
+  makeJayAction,
+  makeJayInit,
+  makeJayQuery,
   makeJayStackComponent,
   notFound,
   partialRender,
+  phaseOutput,
   redirect3xx,
-  serverError5xx
+  serverError5xx,
+  unauthorized
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jay-framework/fullstack-component",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "type": "module",
   "license": "Apache-2.0",
   "main": "dist/index.js",
@@ -26,12 +26,12 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@jay-framework/component": "^0.9.0",
-    "@jay-framework/runtime": "^0.9.0"
+    "@jay-framework/component": "^0.11.0",
+    "@jay-framework/runtime": "^0.11.0"
   },
   "devDependencies": {
-    "@jay-framework/dev-environment": "^0.9.0",
-    "@jay-framework/jay-cli": "^0.9.0",
+    "@jay-framework/dev-environment": "^0.11.0",
+    "@jay-framework/jay-cli": "^0.11.0",
     "@types/express": "^5.0.2",
     "@types/node": "^22.15.21",
     "nodemon": "^3.0.3",