convex-helpers 0.1.2 → 0.1.4

package/README.md

@@ -2,6 +2,44 @@
 
 A collection of useful code to complement the official packages.
 
+## Custom Functions
+
+Build your own customized versions of `query`, `mutation`, and `action` that
+define custom behavior, allowing you to:
+
+- Run authentication logic before the request starts.
+- Look up commonly used data and add it to the ctx argument.
+- Replace a ctx or argument field with a different value, such as a version
+  of `db` that runs custom functions on data access.
+- Consume arguments from the client that are not passed to the action, such
+  as taking in an authentication parameter like an API key or session ID.
+  These arguments must be sent up by the client along with each request.
+
+For example:
+```js
+import { customQuery } from "convex-helpers/server/customFunctions.js
+
+const myQueryBuilder = customQuery(query, {
+  args: { sessionId: v.id("sessions") },
+  input: async (ctx, args) => {
+    const user = await getUserOrNull(ctx);
+    const session = await db.get(sessionId);
+    const db = wrapDatabaseReader({ user }, ctx.db, rlsRules);
+    return { ctx: { db, user, session }, args: {} };
+  },
+});
+
+// Using the custom builder everywhere you would have used `query`
+export const getSomeData = myQueryBuilder({
+  args: { someArg: v.string() },
+  handler: async (ctx, args) => {
+    const { db, user, session, scheduler } = ctx;
+    const { someArg } = args;
+    // ...
+  }
+});
+```
+
 ## Row-level security
 
 See the [Stack post on row-level security](https://stack.convex.dev/row-level-security)

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * asyncMap returns the results of applying an async function over an list.
+ *
+ * @param list - Iterable object of items, e.g. an Array, Set, Object.keys
+ * @param asyncTransform
+ * @returns
+ */
+export declare function asyncMap<FromType, ToType>(list: Iterable<FromType>, asyncTransform: (item: FromType) => Promise<ToType>): Promise<ToType[]>;
+/**
+ * Filters out null elements from an array.
+ * @param list List of elements that might be null.
+ * @returns List of elements with nulls removed.
+ */
+export declare function pruneNull<T>(list: (T | null)[]): T[];

package/dist/index.js

@@ -0,0 +1,22 @@
+/**
+ * asyncMap returns the results of applying an async function over an list.
+ *
+ * @param list - Iterable object of items, e.g. an Array, Set, Object.keys
+ * @param asyncTransform
+ * @returns
+ */
+export async function asyncMap(list, asyncTransform) {
+    const promises = [];
+    for (const item of list) {
+        promises.push(asyncTransform(item));
+    }
+    return Promise.all(promises);
+}
+/**
+ * Filters out null elements from an array.
+ * @param list List of elements that might be null.
+ * @returns List of elements with nulls removed.
+ */
+export function pruneNull(list) {
+    return list.filter((i) => i !== null);
+}

package/dist/server/customFunctions.d.ts

@@ -0,0 +1,245 @@
+/**
+ * This file contains helpers for defining custom functions that modify the
+ * context and arguments of a Convex function. Allows you to:
+ *
+ * - Run authentication logic before the request starts.
+ * - Look up commonly used data and add it to the ctx argument.
+ * - Replace a ctx or argument field with a different value, such as a version
+ *   of `db` that runs custom functions on data access.
+ * - Consume arguments from the client that are not passed to the query, such
+ *   as taking in an authentication parameter like an API key or session ID.
+ *   These arguments must be sent up by the client along with each request.
+ */
+import { ObjectType, PropertyValidators } from "convex/values";
+import { ActionBuilder, FunctionVisibility, GenericActionCtx, GenericDataModel, GenericMutationCtx, GenericQueryCtx, MutationBuilder, QueryBuilder, RegisteredAction, RegisteredMutation, RegisteredQuery, UnvalidatedFunction } from "convex/server";
+/**
+ * A modifier for a query, mutation, or action.
+ *
+ * This defines what arguments are required for the modifier, and how to modify
+ * the ctx and args. If the required args are not returned, they will not be
+ * provided for the modified function. All returned ctx and args will show up
+ * in the type signature for the modified function.
+ * To remove something from `ctx`, you can return it as `undefined`.
+ */
+export type Mod<Ctx extends Record<string, any>, ModArgsValidator extends PropertyValidators, ModCtx extends Record<string, any>, ModMadeArgs extends Record<string, any>> = {
+    args: ModArgsValidator;
+    input: (ctx: Ctx, args: ObjectType<ModArgsValidator>) => Promise<{
+        ctx: ModCtx;
+        args: ModMadeArgs;
+    }> | {
+        ctx: ModCtx;
+        args: ModMadeArgs;
+    };
+};
+/**
+ * A helper for defining a Mod when your mod doesn't need to add or remove
+ * anything from args.
+ * @param mod A function that defines how to modify the ctx.
+ * @returns A ctx delta to be applied to the original ctx.
+ */
+export declare function customCtx<InCtx extends Record<string, any>, OutCtx extends Record<string, any>>(mod: (original: InCtx) => Promise<OutCtx> | OutCtx): Mod<InCtx, {}, OutCtx, {}>;
+/**
+ * A Mod that doesn't add or remove any context or args.
+ */
+export declare const NoOp: {
+    args: {};
+    input(): {
+        args: {};
+        ctx: {};
+    };
+};
+/**
+ * customQuery helps define custom behavior on top of `query` or `internalQuery`
+ * by passing a function that modifies the ctx and args.
+ *
+ * Example usage:
+ * ```js
+ * const myQueryBuilder = customQuery(query, {
+ *   args: { sessionId: v.id("sessions") },
+ *   input: async (ctx, args) => {
+ *     const user = await getUserOrNull(ctx);
+ *     const session = await db.get(sessionId);
+ *     const db = wrapDatabaseReader({ user }, ctx.db, rlsRules);
+ *     return { ctx: { db, user, session }, args: {} };
+ *   },
+ * });
+ *
+ * // Using the custom builder
+ * export const getSomeData = myQueryBuilder({
+ *   args: { someArg: v.string() },
+ *   handler: async (ctx, args) => {
+ *     const { db, user, session, scheduler } = ctx;
+ *     const { someArg } = args;
+ *     // ...
+ *   }
+ * });
+ * ```
+ *
+ * Simple usage only modifying ctx:
+ * ```js
+ * const myInternalQuery = customQuery(
+ *   internalQuery,
+ *   customCtx(async (ctx) => {
+ *     return {
+ *       // Throws an exception if the user isn't logged in
+ *       user: await getUserByTokenIdentifier(ctx),
+ *     };
+ *   })
+ * );
+ *
+ * // Using it
+ * export const getUser = myInternalQuery({
+ *   args: {},
+ *   handler: async (ctx, args) => {
+ *     return ctx.user;
+ *   },
+ * });
+ *
+ * @param query The query to be modified. Usually `query` or `internalQuery`
+ *   from `_generated/server`.
+ * @param mod The modifier to be applied to the query, changing ctx and args.
+ * @returns A new query builder to define queries with modified ctx and args.
+ */
+export declare function customQuery<ModArgsValidator extends PropertyValidators, ModCtx extends Record<string, any>, ModMadeArgs extends Record<string, any>, Visibility extends FunctionVisibility, DataModel extends GenericDataModel>(query: QueryBuilder<DataModel, Visibility>, mod: Mod<GenericQueryCtx<DataModel>, ModArgsValidator, ModCtx, ModMadeArgs>): CustomBuilder<"query", ModArgsValidator, ModCtx, ModMadeArgs, GenericQueryCtx<DataModel>, Visibility>;
+/**
+ * customMutation helps define custom behavior on top of `mutation`
+ * or `internalMutation` by passing a function that modifies the ctx and args.
+ *
+ * Example usage:
+ * ```js
+ * const myMutationBuilder = customMutation(mutation, {
+ *   args: { sessionId: v.id("sessions") },
+ *   input: async (ctx, args) => {
+ *     const user = await getUserOrNull(ctx);
+ *     const session = await db.get(sessionId);
+ *     const db = wrapDatabaseReader({ user }, ctx.db, rlsRules);
+ *     return { ctx: { db, user, session }, args: {} };
+ *   },
+ * });
+ *
+ * // Using the custom builder
+ * export const setSomeData = myMutationBuilder({
+ *   args: { someArg: v.string() },
+ *   handler: async (ctx, args) => {
+ *     const { db, user, session, scheduler } = ctx;
+ *     const { someArg } = args;
+ *     // ...
+ *   }
+ * });
+ * ```
+ *
+ * Simple usage only modifying ctx:
+ * ```js
+ * const myUserMutation = customMutation(
+ *   mutation,
+ *   customCtx(async (ctx) => {
+ *     return {
+ *       // Throws an exception if the user isn't logged in
+ *       user: await getUserByTokenIdentifier(ctx),
+ *     };
+ *   })
+ * );
+ *
+ * // Using it
+ * export const setMyName = myUserMutation({
+ *   args: { name: v.string() },
+ *   handler: async (ctx, args) => {
+ *     await ctx.db.patch(ctx.user._id, { name: args.name });
+ *   },
+ * });
+ *
+ * @param mutation The mutation to be modified. Usually `mutation` or `internalMutation`
+ *   from `_generated/server`.
+ * @param mod The modifier to be applied to the mutation, changing ctx and args.
+ * @returns A new mutation builder to define queries with modified ctx and args.
+ */
+export declare function customMutation<ModArgsValidator extends PropertyValidators, ModCtx extends Record<string, any>, ModMadeArgs extends Record<string, any>, Visibility extends FunctionVisibility, DataModel extends GenericDataModel>(mutation: MutationBuilder<DataModel, Visibility>, mod: Mod<GenericMutationCtx<DataModel>, ModArgsValidator, ModCtx, ModMadeArgs>): CustomBuilder<"mutation", ModArgsValidator, ModCtx, ModMadeArgs, GenericMutationCtx<DataModel>, Visibility>;
+/**
+ * customAction helps define custom behavior on top of `action`
+ * or `internalAction` by passing a function that modifies the ctx and args.
+ *
+ * Example usage:
+ * ```js
+ * const myActionBuilder = customAction(action, {
+ *   args: { secretKey: v.string() },
+ *   input: async (ctx, args) => {
+ *     // Very basic authorization, e.g. from trusted backends.
+ *     if (args.secretKey !== process.env.SECRET_KEY) {
+ *       throw new Error("Invalid secret key");
+ *     }
+ *     const user = await ctx.runQuery(internal.users.getUser, {});
+ *     return { ctx: { user }, args: {} };
+ *   },
+ * });
+ *
+ * // Using the custom builder
+ * export const runSomeAction = myActionBuilder({
+ *   args: { someArg: v.string() },
+ *   handler: async (ctx, args) => {
+ *     const { user, scheduler } = ctx;
+ *     const { someArg } = args;
+ *     // ...
+ *   }
+ * });
+ * ```
+ *
+ * Simple usage only modifying ctx:
+ * ```js
+ * const myUserAction = customAction(
+ *   internalAction,
+ *   customCtx(async (ctx) => {
+ *     return {
+ *       // Throws an exception if the user isn't logged in
+ *       user: await ctx.runQuery(internal.users.getUser, {});
+ *     };
+ *   })
+ * );
+ *
+ * // Using it
+ * export const sendUserEmail = myUserAction({
+ *   args: { subject: v.string(), body: v.string() },
+ *   handler: async (ctx, args) => {
+ *     await sendEmail(ctx.user.email, args.subject, args.body);
+ *   },
+ * });
+ *
+ * @param action The action to be modified. Usually `action` or `internalAction`
+ *   from `_generated/server`.
+ * @param mod The modifier to be applied to the action, changing ctx and args.
+ * @returns A new action builder to define queries with modified ctx and args.
+ */
+export declare function customAction<ModArgsValidator extends PropertyValidators, ModCtx extends Record<string, any>, ModMadeArgs extends Record<string, any>, Visibility extends FunctionVisibility, DataModel extends GenericDataModel>(action: ActionBuilder<DataModel, Visibility>, mod: Mod<GenericActionCtx<DataModel>, ModArgsValidator, ModCtx, ModMadeArgs>): CustomBuilder<"action", ModArgsValidator, ModCtx, ModMadeArgs, GenericActionCtx<DataModel>, Visibility>;
+/**
+ * A Convex function (query, mutation, or action) to be registered for the API.
+ * Convenience to specify the registration type based on function type.
+ */
+type Registration<FuncType extends "query" | "mutation" | "action", Visibility extends FunctionVisibility, Args extends DefaultFunctionArgs, Output> = {
+    query: RegisteredQuery<Visibility, Args, Output>;
+    mutation: RegisteredMutation<Visibility, Args, Output>;
+    action: RegisteredAction<Visibility, Args, Output>;
+}[FuncType];
+/**
+ * A builder that customizes a Convex function using argument validation.
+ * e.g. `query({ args: {}, handler: async (ctx, args) => {} })`
+ */
+type ValidatedBuilder<FuncType extends "query" | "mutation" | "action", ModArgsValidator extends PropertyValidators, ModCtx extends Record<string, any>, ModMadeArgs extends Record<string, any>, InputCtx, Visibility extends FunctionVisibility> = <ExistingArgsValidator extends PropertyValidators, Output>(fn: {
+    args: ExistingArgsValidator;
+    handler: (ctx: InputCtx & ModCtx, args: ObjectType<ExistingArgsValidator> & ModMadeArgs) => Output;
+}) => Registration<FuncType, Visibility, ObjectType<ExistingArgsValidator & ModArgsValidator>, Output>;
+/**
+ * A builder that customizes a Convex function which doesn't validate arguments.
+ * e.g. `query(async (ctx, args) => {})`
+ * or `query({ handler: async (ctx, args) => {} })`
+ */
+type UnvalidatedBuilder<FuncType extends "query" | "mutation" | "action", ModCtx extends Record<string, any>, ModMadeArgs extends Record<string, any>, InputCtx, Visibility extends FunctionVisibility> = <Output, ExistingArgs extends DefaultFunctionArgs = DefaultFunctionArgs>(fn: UnvalidatedFunction<InputCtx & ModCtx, [
+    ExistingArgs & ModMadeArgs
+], Output>) => Registration<FuncType, Visibility, ExistingArgs, Output>;
+/**
+ * A builder that customizes a Convex function, whether or not it validates
+ * arguments. If the customization requires arguments, however, the resulting
+ * builder will require argument validation too.
+ */
+type CustomBuilder<FuncType extends "query" | "mutation" | "action", ModArgsValidator extends PropertyValidators, ModCtx extends Record<string, any>, ModMadeArgs extends Record<string, any>, InputCtx, Visibility extends FunctionVisibility> = ModArgsValidator extends EmptyObject ? ValidatedBuilder<FuncType, ModArgsValidator, ModCtx, ModMadeArgs, InputCtx, Visibility> & UnvalidatedBuilder<FuncType, ModCtx, ModMadeArgs, InputCtx, Visibility> : ValidatedBuilder<FuncType, ModArgsValidator, ModCtx, ModMadeArgs, InputCtx, Visibility>;
+type EmptyObject = Record<string, never>;
+type DefaultFunctionArgs = Record<string, unknown>;
+export {};

package/dist/server/customFunctions.js

@@ -0,0 +1,295 @@
+/**
+ * A helper for defining a Mod when your mod doesn't need to add or remove
+ * anything from args.
+ * @param mod A function that defines how to modify the ctx.
+ * @returns A ctx delta to be applied to the original ctx.
+ */
+export function customCtx(mod) {
+    return {
+        args: {},
+        input: async (ctx) => ({ ctx: await mod(ctx), args: {} }),
+    };
+}
+/**
+ * A Mod that doesn't add or remove any context or args.
+ */
+export const NoOp = {
+    args: {},
+    input() {
+        return { args: {}, ctx: {} };
+    },
+};
+/**
+ * customQuery helps define custom behavior on top of `query` or `internalQuery`
+ * by passing a function that modifies the ctx and args.
+ *
+ * Example usage:
+ * ```js
+ * const myQueryBuilder = customQuery(query, {
+ *   args: { sessionId: v.id("sessions") },
+ *   input: async (ctx, args) => {
+ *     const user = await getUserOrNull(ctx);
+ *     const session = await db.get(sessionId);
+ *     const db = wrapDatabaseReader({ user }, ctx.db, rlsRules);
+ *     return { ctx: { db, user, session }, args: {} };
+ *   },
+ * });
+ *
+ * // Using the custom builder
+ * export const getSomeData = myQueryBuilder({
+ *   args: { someArg: v.string() },
+ *   handler: async (ctx, args) => {
+ *     const { db, user, session, scheduler } = ctx;
+ *     const { someArg } = args;
+ *     // ...
+ *   }
+ * });
+ * ```
+ *
+ * Simple usage only modifying ctx:
+ * ```js
+ * const myInternalQuery = customQuery(
+ *   internalQuery,
+ *   customCtx(async (ctx) => {
+ *     return {
+ *       // Throws an exception if the user isn't logged in
+ *       user: await getUserByTokenIdentifier(ctx),
+ *     };
+ *   })
+ * );
+ *
+ * // Using it
+ * export const getUser = myInternalQuery({
+ *   args: {},
+ *   handler: async (ctx, args) => {
+ *     return ctx.user;
+ *   },
+ * });
+ *
+ * @param query The query to be modified. Usually `query` or `internalQuery`
+ *   from `_generated/server`.
+ * @param mod The modifier to be applied to the query, changing ctx and args.
+ * @returns A new query builder to define queries with modified ctx and args.
+ */
+export function customQuery(query, mod) {
+    function customQueryBuilder(fn) {
+        // Looking forward to when input / args / ... are optional
+        const inputMod = mod.input ?? NoOp.input;
+        const inputArgs = mod.args ?? NoOp.args;
+        if ("args" in fn) {
+            return query({
+                args: {
+                    ...fn.args,
+                    ...inputArgs,
+                },
+                handler: async (ctx, allArgs) => {
+                    const { split, rest } = splitArgs(inputArgs, allArgs);
+                    const added = await inputMod(ctx, split);
+                    return await fn.handler({ ...ctx, ...added.ctx }, { ...rest, ...added.args });
+                },
+            });
+        }
+        if (Object.keys(inputArgs).length > 0) {
+            throw new Error("If you're using a custom function with arguments for the input " +
+                "modifier, you must declare the arguments for the function too.");
+        }
+        const handler = fn.handler ?? fn;
+        return query({
+            handler: async (ctx, args) => {
+                const { ctx: modCtx } = await inputMod(ctx, args);
+                return await handler({ ...ctx, ...modCtx }, args);
+            },
+        });
+    }
+    return customQueryBuilder;
+}
+/**
+ * customMutation helps define custom behavior on top of `mutation`
+ * or `internalMutation` by passing a function that modifies the ctx and args.
+ *
+ * Example usage:
+ * ```js
+ * const myMutationBuilder = customMutation(mutation, {
+ *   args: { sessionId: v.id("sessions") },
+ *   input: async (ctx, args) => {
+ *     const user = await getUserOrNull(ctx);
+ *     const session = await db.get(sessionId);
+ *     const db = wrapDatabaseReader({ user }, ctx.db, rlsRules);
+ *     return { ctx: { db, user, session }, args: {} };
+ *   },
+ * });
+ *
+ * // Using the custom builder
+ * export const setSomeData = myMutationBuilder({
+ *   args: { someArg: v.string() },
+ *   handler: async (ctx, args) => {
+ *     const { db, user, session, scheduler } = ctx;
+ *     const { someArg } = args;
+ *     // ...
+ *   }
+ * });
+ * ```
+ *
+ * Simple usage only modifying ctx:
+ * ```js
+ * const myUserMutation = customMutation(
+ *   mutation,
+ *   customCtx(async (ctx) => {
+ *     return {
+ *       // Throws an exception if the user isn't logged in
+ *       user: await getUserByTokenIdentifier(ctx),
+ *     };
+ *   })
+ * );
+ *
+ * // Using it
+ * export const setMyName = myUserMutation({
+ *   args: { name: v.string() },
+ *   handler: async (ctx, args) => {
+ *     await ctx.db.patch(ctx.user._id, { name: args.name });
+ *   },
+ * });
+ *
+ * @param mutation The mutation to be modified. Usually `mutation` or `internalMutation`
+ *   from `_generated/server`.
+ * @param mod The modifier to be applied to the mutation, changing ctx and args.
+ * @returns A new mutation builder to define queries with modified ctx and args.
+ */
+export function customMutation(mutation, mod) {
+    function customMutationBuilder(fn) {
+        // Looking forward to when input / args / ... are optional
+        const inputMod = mod.input ?? NoOp.input;
+        const inputArgs = mod.args ?? NoOp.args;
+        if ("args" in fn) {
+            return mutation({
+                args: {
+                    ...fn.args,
+                    ...inputArgs,
+                },
+                handler: async (ctx, allArgs) => {
+                    const { split, rest } = splitArgs(inputArgs, allArgs);
+                    const added = await inputMod(ctx, split);
+                    return await fn.handler({ ...ctx, ...added.ctx }, { ...rest, ...added.args });
+                },
+            });
+        }
+        if (Object.keys(inputArgs).length > 0) {
+            throw new Error("If you're using a custom function with arguments for the input " +
+                "modifier, you must declare the arguments for the function too.");
+        }
+        const handler = fn.handler ?? fn;
+        return mutation({
+            handler: async (ctx, args) => {
+                const { ctx: modCtx } = await inputMod(ctx, args);
+                return await handler({ ...ctx, ...modCtx }, args);
+            },
+        });
+    }
+    return customMutationBuilder;
+}
+/**
+ * customAction helps define custom behavior on top of `action`
+ * or `internalAction` by passing a function that modifies the ctx and args.
+ *
+ * Example usage:
+ * ```js
+ * const myActionBuilder = customAction(action, {
+ *   args: { secretKey: v.string() },
+ *   input: async (ctx, args) => {
+ *     // Very basic authorization, e.g. from trusted backends.
+ *     if (args.secretKey !== process.env.SECRET_KEY) {
+ *       throw new Error("Invalid secret key");
+ *     }
+ *     const user = await ctx.runQuery(internal.users.getUser, {});
+ *     return { ctx: { user }, args: {} };
+ *   },
+ * });
+ *
+ * // Using the custom builder
+ * export const runSomeAction = myActionBuilder({
+ *   args: { someArg: v.string() },
+ *   handler: async (ctx, args) => {
+ *     const { user, scheduler } = ctx;
+ *     const { someArg } = args;
+ *     // ...
+ *   }
+ * });
+ * ```
+ *
+ * Simple usage only modifying ctx:
+ * ```js
+ * const myUserAction = customAction(
+ *   internalAction,
+ *   customCtx(async (ctx) => {
+ *     return {
+ *       // Throws an exception if the user isn't logged in
+ *       user: await ctx.runQuery(internal.users.getUser, {});
+ *     };
+ *   })
+ * );
+ *
+ * // Using it
+ * export const sendUserEmail = myUserAction({
+ *   args: { subject: v.string(), body: v.string() },
+ *   handler: async (ctx, args) => {
+ *     await sendEmail(ctx.user.email, args.subject, args.body);
+ *   },
+ * });
+ *
+ * @param action The action to be modified. Usually `action` or `internalAction`
+ *   from `_generated/server`.
+ * @param mod The modifier to be applied to the action, changing ctx and args.
+ * @returns A new action builder to define queries with modified ctx and args.
+ */
+export function customAction(action, mod) {
+    function customActionBuilder(fn) {
+        // Looking forward to when input / args / ... are optional
+        const inputMod = mod.input ?? NoOp.input;
+        const inputArgs = mod.args ?? NoOp.args;
+        if ("args" in fn) {
+            return action({
+                args: {
+                    ...fn.args,
+                    ...inputArgs,
+                },
+                handler: async (ctx, allArgs) => {
+                    const { split, rest } = splitArgs(inputArgs, allArgs);
+                    const added = await inputMod(ctx, split);
+                    return await fn.handler({ ...ctx, ...added.ctx }, { ...rest, ...added.args });
+                },
+            });
+        }
+        if (Object.keys(inputArgs).length > 0) {
+            throw new Error("If you're using a custom function with arguments for the input " +
+                "modifier, you must declare the arguments for the function too.");
+        }
+        const handler = fn.handler ?? fn;
+        return action({
+            handler: async (ctx, args) => {
+                const { ctx: modCtx } = await inputMod(ctx, args);
+                return await handler({ ...ctx, ...modCtx }, args);
+            },
+        });
+    }
+    return customActionBuilder;
+}
+/**
+ *
+ * @param splitArgsValidator The args that should be split out from the rest.
+ *   As an object mapping arg names to validators (v.* from convex/values).
+ * @param args The arguments to a function, including values to be split out.
+ * @returns The args split into two objects: `split` and `rest` based on keys.
+ */
+function splitArgs(splitArgsValidator, args) {
+    const rest = {};
+    const split = {};
+    for (const arg in args) {
+        if (arg in splitArgsValidator) {
+            split[arg] = args[arg];
+        }
+        else {
+            rest[arg] = args[arg];
+        }
+    }
+    return { split, rest };
+}

package/dist/server/index.js

@@ -0,0 +1 @@
+"use strict";