@tailorkit/app 0.1.0-beta.2 → 0.1.0-beta.21

package/dist/chunk-7NOEYJOB.js

@@ -0,0 +1,197 @@
+import {
+  AppError
+} from "./chunk-IJBQ77AH.js";
+
+// src/server/functions.ts
+function query(definition) {
+  return Object.freeze({ ...definition, kind: "query" });
+}
+function mutation(definition) {
+  return Object.freeze({ ...definition, kind: "mutation" });
+}
+function action(definition) {
+  return Object.freeze({ ...definition, kind: "action" });
+}
+function isFunction(value) {
+  return typeof value.kind === "string" && typeof value.handler === "function";
+}
+function 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/server/builder.ts
+import { z } from "zod";
+var FunctionBuilder = class _FunctionBuilder {
+  kind;
+  args;
+  result;
+  calls;
+  constructor(kind, args, result, calls) {
+    this.kind = kind;
+    this.args = args;
+    this.result = result;
+    this.calls = calls;
+  }
+  input(schema) {
+    return new _FunctionBuilder(this.kind, schema, this.result, this.calls);
+  }
+  output(schema) {
+    return new _FunctionBuilder(this.kind, this.args, schema, this.calls);
+  }
+  functions(functions) {
+    return new _FunctionBuilder(this.kind, this.args, this.result, functions);
+  }
+  handler(handler) {
+    return Object.freeze({
+      kind: this.kind,
+      args: this.args,
+      ...this.result ? { result: this.result } : {},
+      ...this.kind === "action" ? { functions: this.calls } : {},
+      handler: (context) => handler({ ...context, input: context.args })
+    });
+  }
+};
+var tk = Object.freeze({
+  query: new FunctionBuilder("query", z.undefined(), void 0, {}),
+  mutation: new FunctionBuilder("mutation", z.undefined(), void 0, {}),
+  action: new FunctionBuilder("action", z.undefined(), void 0, {})
+});
+
+// src/server/instances.ts
+import { z as z2 } from "zod";
+var addressSchema = z2.object({
+  slot: z2.string().min(1).max(255),
+  path: z2.string().startsWith("/").max(1024)
+});
+function registeredQueries(functions) {
+  const queries = {};
+  for (const [name, fn] of Object.entries(functions)) {
+    if (isFunction(fn)) {
+      if (fn.kind === "query") queries[name] = fn;
+    } else {
+      const nested = registeredQueries(fn);
+      if (Object.keys(nested).length) queries[name] = nested;
+    }
+  }
+  return queries;
+}
+function 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) {
+    addressSchema.parse(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}".`
+      );
+    }
+    const result = z2.array(
+      z2.object({
+        key: z2.string().min(1),
+        metadata: z2.record(z2.string(), z2.unknown()),
+        data: resolver.dataSchema
+      })
+    ).refine((items) => new Set(items.map((item) => item.key)).size === items.length, {
+      message: "Instance keys must be unique"
+    });
+    paths.set(resolver.path, { resolver, result });
+  }
+  const instances = {
+    resolve: action({
+      functions: queries,
+      args: addressSchema.extend({ context: z2.record(z2.string(), z2.unknown()) }),
+      async handler({ args, identity, signal, queries: queries2 }) {
+        const entry = registry.get(args.slot)?.get(args.path);
+        if (!entry) throw new AppError("NOT_FOUND", "Instance resolver not found");
+        const value = await entry.resolver.resolve({
+          context: args.context,
+          identity,
+          signal,
+          queries: queries2
+        });
+        const result = entry.result.safeParse(value);
+        if (!result.success) throw new AppError("INTERNAL_SERVER_ERROR", "Invalid function result");
+        return result.data;
+      }
+    })
+  };
+  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";
+function 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,
+  tk,
+  withInstanceResolvers,
+  table,
+  text,
+  integer,
+  real,
+  boolean,
+  eq,
+  ne,
+  gt,
+  gte,
+  lt,
+  lte,
+  and,
+  or,
+  asc,
+  desc,
+  count,
+  isNull,
+  isNotNull,
+  inArray
+};

package/dist/{chunk-7L6ZZHCK.js → chunk-DEU6RITM.js}

@@ -1,6 +1,6 @@
 import {
   tailorkitConfigSchema
-} from "./chunk-AGGRUUWG.js";
+} from "./chunk-GVB2PAK7.js";
 
 // src/config/loader.ts
 import { cosmiconfig } from "cosmiconfig";
@@ -14,6 +14,11 @@ var loadTailorKitConfig = async (configPath, cwd = process.cwd()) => {
   if (result === null) {
     throw new Error(`Could not find tailorkit config from ${searchFrom}.`);
   }
+  if (result.config && typeof result.config === "object" && "storage" in result.config) {
+    throw new Error(
+      "The legacy storage configuration was removed. Use server configuration and @tailorkit/app."
+    );
+  }
   return {
     config: tailorkitConfigSchema.parse(result.config),
     filepath: result.filepath,

package/dist/chunk-GVB2PAK7.js

@@ -0,0 +1,28 @@
+// src/config/config.ts
+import { z } from "zod";
+var buildConfigSchema = z.object({
+  outDir: z.string().default(".tailorkit")
+});
+var logosConfigSchema = z.object({
+  dark: z.string().min(1).optional(),
+  light: z.string().min(1).optional()
+});
+var tailorkitConfigSchema = z.strictObject({
+  appId: z.string().min(1).optional(),
+  build: buildConfigSchema.optional(),
+  client: z.strictObject({ entry: z.string().min(1).default("src/client.ts") }).optional(),
+  host: z.string().url(),
+  logos: logosConfigSchema.optional(),
+  server: z.strictObject({
+    entry: z.string().min(1).default("src/server.ts"),
+    migrations: z.string().min(1).optional()
+  }).optional()
+});
+var defineConfig = (config) => config;
+var defineTailorKitConfig = defineConfig;
+
+export {
+  tailorkitConfigSchema,
+  defineConfig,
+  defineTailorKitConfig
+};

package/dist/chunk-IJBQ77AH.js

@@ -0,0 +1,35 @@
+// src/errors.ts
+var AppError = class extends Error {
+  constructor(code, message = code) {
+    super(message);
+    this.code = code;
+    this.name = "AppError";
+  }
+  code;
+};
+function appError(error) {
+  if (error instanceof AppError) return error;
+  if (error instanceof Error && error.name === "AbortError")
+    return new AppError("UNAVAILABLE", "App connection interrupted");
+  if (error && typeof error === "object" && "code" in error && error.code === "NETWORK_ERROR")
+    return new AppError("UNAVAILABLE", "App connection interrupted");
+  if (error && typeof error === "object" && "code" in error && [
+    "BAD_REQUEST",
+    "UNAUTHORIZED",
+    "FORBIDDEN",
+    "NOT_FOUND",
+    "CONFLICT",
+    "INCOMPATIBLE_VERSION",
+    "UNAVAILABLE"
+  ].includes(String(error.code)))
+    return new AppError(
+      error.code,
+      "message" in error ? String(error.message) : String(error.code)
+    );
+  return new AppError("INTERNAL_SERVER_ERROR", "App function failed");
+}
+
+export {
+  AppError,
+  appError
+};