@yangcurve/actions/dist/index.cjs

Server Action wrapper inspired by trpc.

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  initActions: () => initActions
});
module.exports = __toCommonJS(src_exports);

// src/caller.ts
var createCallerFactory = ({ transformer }) => {
  const createCaller = (actions, path = []) => new Proxy(
    {},
    {
      get: (_, key) => {
        const action = [...path, key].reduce((acc, key2) => acc[key2], actions);
        if (typeof action === "function")
          return async (input) => {
            const output = await action(input);
            return transformer?.parse?.(output) ?? output;
          };
        return createCaller(actions, [...path, key]);
      }
    }
  );
  return createCaller;
};

// src/client/proxy.ts
var import_react_query = require("@tanstack/react-query");
var createClientProxy = (actions, ...path) => new Proxy(
  {},
  {
    get: (_, key) => key === "useQuery" ? (input, options, queryClient) => (0, import_react_query.useQuery)(
      {
        ...options,
        // @ts-expect-error ...
        queryFn: () => path.reduce((acc, key2) => acc[key2], actions)(input),
        queryKey: [...path, input]
      },
      queryClient
    ) : key === "useMutation" ? (options, queryClient) => (0, import_react_query.useMutation)(
      {
        ...options,
        // @ts-expect-error ...
        mutationFn: (input) => path.reduce((acc, key2) => acc[key2], actions)(input),
        mutationKey: path
      },
      queryClient
    ) : createClientProxy(actions, ...path, key)
  }
);

// src/client/utils.ts
var createClientUtils = (actions, queryClient, path = []) => new Proxy(
  {},
  {
    get: (_, key) => key === "invalidate" ? (input) => queryClient.invalidateQueries({ queryKey: [...path, input].filter(Boolean) }) : key === "isMutating" ? () => queryClient.isMutating({ mutationKey: path }) : createClientUtils(actions, queryClient, [...path, key])
  }
);

// src/client/caller.ts
var import_react_query2 = require("@tanstack/react-query");
var createClientCaller = (actions) => new Proxy(
  {},
  {
    get: (_, key) => key === "useUtils" ? () => {
      const queryClient = (0, import_react_query2.useQueryClient)();
      return createClientUtils(actions, queryClient);
    } : createClientProxy(actions, key)
  }
);

// src/procedure.ts
var import_zod = require("zod");
var createProcedureFactory = ({ transformer }) => {
  const __createProcedure = ({ createContext, middlewares }) => {
    const getActionBuilder = (Schema) => (resolver) => async (input) => {
      const invokeMiddlewares = async (ctx, ...middlewares2) => middlewares2.length === 0 ? await resolver({ ctx, input: Schema.parse(input) }) : await middlewares2[0]({
        ctx,
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        next: async (newCtx) => await invokeMiddlewares(newCtx ?? ctx, ...middlewares2.slice(1))
      });
      const output = await invokeMiddlewares(await createContext(), ...middlewares);
      return transformer?.stringify(output) ?? output;
    };
    return {
      use: (middleware) => __createProcedure({
        createContext,
        middlewares: [...middlewares, middleware]
      }),
      query: getActionBuilder(import_zod.z.void()),
      mutation: getActionBuilder(import_zod.z.void()),
      input: (Schema) => ({
        query: getActionBuilder(Schema),
        mutation: getActionBuilder(Schema)
      })
    };
  };
  const createProcedure = ({
    createContext
  } = {}) => __createProcedure({
    createContext: createContext ?? (() => new Promise(() => {
    })),
    middlewares: []
  });
  return createProcedure;
};

// src/init.ts
var initActions = ({ transformer } = {}) => ({
  createProcedure: createProcedureFactory({ transformer }),
  createCaller: createCallerFactory({ transformer }),
  createClientCaller
});
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  initActions
});