@tailorkit/app 0.1.0-beta.9 → 1.0.0-beta.44

package/dist/chunk-QDZXHVTU.js

@@ -0,0 +1,277 @@
+import {
+  AppError
+} from "./chunk-7ZQPXG7O.js";
+
+// src/server/functions.ts
+var query = (definition) => Object.freeze({ ...definition, kind: "query" });
+var mutation = (definition) => Object.freeze({ ...definition, kind: "mutation" });
+var action = (definition) => Object.freeze({ ...definition, kind: "action" });
+var isFunction = (value) => typeof value.kind === "string" && typeof value.handler === "function";
+var defineServer = (functions) => {
+  for (const [name, value] of Object.entries(functions)) {
+    if (!/^[a-zA-Z][a-zA-Z0-9_]{0,63}$/u.test(name)) {
+      throw new Error("Invalid function name");
+    }
+    if (!isFunction(value)) {
+      defineServer(value);
+    }
+  }
+  return Object.freeze({ functions });
+};
+
+// src/database/definition.ts
+var defineDatabase = (definition) => Object.freeze({ relations: definition.relations });
+
+// src/server/builder.ts
+import * as v from "valibot";
+var FunctionBuilder = class _FunctionBuilder {
+  kind;
+  args;
+  result;
+  calls;
+  databaseDefinition;
+  constructor(kind, args, result, calls, database) {
+    this.kind = kind;
+    this.args = args;
+    this.result = result;
+    this.calls = calls;
+    this.databaseDefinition = database;
+  }
+  input(schema) {
+    return new _FunctionBuilder(
+      this.kind,
+      schema,
+      this.result,
+      this.calls,
+      this.databaseDefinition
+    );
+  }
+  output(schema) {
+    return new _FunctionBuilder(
+      this.kind,
+      this.args,
+      schema,
+      this.calls,
+      this.databaseDefinition
+    );
+  }
+  functions(functions) {
+    return new _FunctionBuilder(
+      this.kind,
+      this.args,
+      this.result,
+      functions,
+      this.databaseDefinition
+    );
+  }
+  database(database) {
+    return new _FunctionBuilder(
+      this.kind,
+      this.args,
+      this.result,
+      this.calls,
+      database
+    );
+  }
+  handler(handler) {
+    const metadata = {};
+    if (this.databaseDefinition) {
+      metadata.database = this.databaseDefinition;
+    }
+    if (this.result) {
+      metadata.result = this.result;
+    }
+    if (this.kind === "action") {
+      metadata.functions = this.calls;
+    }
+    return (
+      /* oxlint-disable typescript/no-unsafe-type-assertion, anti-slop/no-chained-type-assertions -- This builder or fixture preserves the declared capabilities across an erased generic boundary. */
+      Object.freeze({
+        ...metadata,
+        args: this.args,
+        handler: (context) => (
+          // SAFETY: The adapter reconstructs the same runtime contract, but TypeScript cannot relate the erased generic parameters across this library boundary.
+          // oxlint-disable-next-line anti-slop/no-chained-type-assertions -- The adapter reconstructs the same runtime contract, but TypeScript cannot relate the erased generic parameters across this library boundary.
+          handler({
+            ...context,
+            input: context.args
+          })
+        ),
+        kind: this.kind
+      })
+    );
+  }
+};
+var fn = Object.freeze({
+  action: new FunctionBuilder("action", v.undefined(), void 0, {}),
+  mutation: new FunctionBuilder("mutation", v.undefined(), void 0, {}),
+  query: new FunctionBuilder("query", v.undefined(), void 0, {})
+});
+
+// src/server/instances.ts
+import * as v2 from "valibot";
+var addressSchema = v2.object({
+  path: v2.pipe(v2.string(), v2.startsWith("/"), v2.maxLength(1024)),
+  slot: v2.pipe(v2.string(), v2.minLength(1), v2.maxLength(255))
+});
+var instanceResults = v2.pipe(
+  v2.array(
+    v2.object({
+      data: v2.unknown(),
+      key: v2.pipe(v2.string(), v2.minLength(1)),
+      metadata: v2.record(v2.string(), v2.unknown())
+    })
+  ),
+  v2.check(
+    (items) => new Set(items.map((item) => item.key)).size === items.length,
+    "Instance keys must be unique"
+  )
+);
+var registeredQueries = (functions) => {
+  const queries = {};
+  for (const [name, fn2] of Object.entries(functions)) {
+    if (isFunction(fn2)) {
+      if (fn2.kind === "query") {
+        queries[name] = fn2;
+      }
+    } else {
+      const nested = registeredQueries(fn2);
+      if (Object.keys(nested).length) {
+        queries[name] = nested;
+      }
+    }
+  }
+  return queries;
+};
+var withInstanceResolvers = (app, resolvers) => {
+  if (Object.hasOwn(app.functions, "_tailorkit")) {
+    throw new Error(
+      "The _tailorkit function namespace is reserved by TailorKit."
+    );
+  }
+  const queries = registeredQueries(app.functions);
+  const registry = /* @__PURE__ */ new Map();
+  for (const resolver of resolvers) {
+    v2.parse(addressSchema, resolver);
+    let paths = registry.get(resolver.slot);
+    if (!paths) {
+      paths = /* @__PURE__ */ new Map();
+      registry.set(resolver.slot, paths);
+    }
+    if (paths.has(resolver.path)) {
+      throw new Error(
+        `Duplicate instance resolver for slot "${resolver.slot}" and path "${resolver.path}".`
+      );
+    }
+    paths.set(resolver.path, resolver);
+  }
+  const instances = {
+    resolve: action({
+      args: v2.object({
+        ...addressSchema.entries,
+        context: v2.record(v2.string(), v2.unknown())
+      }),
+      functions: queries,
+      handler: async ({ args, identity, signal, queries: queriesValue }) => {
+        const resolver = registry.get(args.slot)?.get(args.path);
+        if (!resolver) {
+          throw new AppError("NOT_FOUND", "Instance resolver not found");
+        }
+        const value = await resolver.resolve({
+          context: args.context,
+          identity,
+          queries: queriesValue,
+          signal
+        });
+        const result = v2.safeParse(instanceResults, value);
+        if (!result.success) {
+          throw new AppError(
+            "INTERNAL_SERVER_ERROR",
+            "Invalid function result"
+          );
+        }
+        return await Promise.all(
+          result.output.map(async (item) => {
+            const parsed = await resolver.dataSchema["~standard"].validate(
+              item.data
+            );
+            if (parsed.issues) {
+              throw new AppError(
+                "INTERNAL_SERVER_ERROR",
+                "Invalid function result"
+              );
+            }
+            return { ...item, data: parsed.value };
+          })
+        );
+      }
+    })
+  };
+  const internal = defineServer({ instances });
+  return Object.freeze({
+    functions: { ...app.functions, _tailorkit: internal.functions }
+  });
+};
+
+// src/database/schema.ts
+import {
+  sqliteTable,
+  text as sqliteText,
+  integer as sqliteInteger,
+  real as sqliteReal
+} from "drizzle-orm/sqlite-core";
+import {
+  eq,
+  ne,
+  gt,
+  gte,
+  lt,
+  lte,
+  and,
+  or,
+  asc,
+  desc,
+  count,
+  isNull,
+  isNotNull,
+  inArray
+} from "drizzle-orm";
+var table = (name, columns) => {
+  if (!/^[a-zA-Z][a-zA-Z0-9_]{0,62}$/u.test(name) || name.startsWith("sqlite_") || name.startsWith("tailorkit_")) {
+    throw new Error("Invalid or reserved table name");
+  }
+  return sqliteTable(name, columns);
+};
+var text = (name = "") => sqliteText(name);
+var integer = (name = "") => sqliteInteger(name);
+var real = (name = "") => sqliteReal(name);
+var boolean = (name = "") => sqliteInteger(name, { mode: "boolean" });
+
+export {
+  query,
+  mutation,
+  action,
+  defineServer,
+  defineDatabase,
+  fn,
+  withInstanceResolvers,
+  table,
+  text,
+  integer,
+  real,
+  boolean,
+  eq,
+  ne,
+  gt,
+  gte,
+  lt,
+  lte,
+  and,
+  or,
+  asc,
+  desc,
+  count,
+  isNull,
+  isNotNull,
+  inArray
+};