apps 0.0.1-beta.9 → 0.0.1-beta.91

package/js/chunk-YXQHV65J.js

@@ -1,242 +0,0 @@
-import {
-  promiseTable
-} from "./chunk-ZQINWV4W.js";
-import {
-  declaredOperations,
-  fromPromise,
-  nativeOperation,
-  nativeRouter
-} from "./chunk-Z5M2LQOZ.js";
-import {
-  ScheduleTiming
-} from "./chunk-WLE7WX2U.js";
-import {
-  DatabaseSchema
-} from "./chunk-N7YDVXYJ.js";
-import {
-  decoderOf,
-  isSchema,
-  storageFieldOf
-} from "./chunk-5T57N25Q.js";
-import {
-  AppStorageUnavailable
-} from "./chunk-PZB6T6KU.js";
-import {
-  JsonValue
-} from "./chunk-27F7W2LG.js";
-import {
-  Effect_exports,
-  Schema_exports
-} from "./chunk-CDL5PM2Q.js";
-
-// src/contracts/http.ts
-var ResponseStatusError = class extends Schema_exports.TaggedError()(
-  "ResponseStatusError",
-  { status: Schema_exports.Number }
-) {
-  get message() {
-    return `Request failed with status ${this.status}`;
-  }
-};
-var ResponseDecodeError = class extends Schema_exports.TaggedError()(
-  "ResponseDecodeError",
-  {}
-) {
-  get message() {
-    return "Response body did not match the expected schema";
-  }
-};
-
-// src/implementation/workflows.ts
-var NativeWorkflow = /* @__PURE__ */ Symbol("apps.Workflow");
-var workflow = (options, run) => ({
-  [NativeWorkflow]: {
-    input: decoderOf(options.input),
-    ...options.output === void 0 ? {} : { output: decoderOf(options.output) },
-    ...options.description === void 0 ? {} : { description: options.description },
-    run: (context, input) => Effect_exports.tryPromise({
-      // SAFETY: defineApp checks required context; the host supplies the pinned run's capabilities.
-      try: () => run(context, input),
-      catch: (error) => error
-    })
-  }
-});
-var nativeWorkflow = (value) => {
-  if (typeof value !== "object" || value === null || !(NativeWorkflow in value)) return void 0;
-  return value[NativeWorkflow];
-};
-
-// src/implementation/app.ts
-var InternalApp = /* @__PURE__ */ Symbol("apps.App");
-var isApp = (value) => typeof value === "object" && value !== null && InternalApp in value;
-var toEffectApp = (app) => app[InternalApp];
-function rejectCatalogs(definition) {
-  if ("queries" in definition || "mutations" in definition)
-    throw new Error("Put queries and mutations in a router under tools");
-}
-function adaptDefinition(definition) {
-  rejectCatalogs(definition);
-  const webhooks = definition.webhooks === void 0 ? {} : {
-    webhooks: Object.fromEntries(
-      Object.entries(definition.webhooks).map(([name, webhook]) => [
-        name,
-        {
-          ...webhook,
-          ...webhook.register === void 0 ? {} : { register: fromPromise(webhook.register) },
-          handle: fromPromise(webhook.handle),
-          ...webhook.unregister === void 0 ? {} : { unregister: fromPromise(webhook.unregister) },
-          ..."config" in webhook && isSchema(webhook.config) ? { config: decoderOf(webhook.config) } : {},
-          ..."state" in webhook && isSchema(webhook.state) ? { state: decoderOf(webhook.state) } : {}
-        }
-      ])
-    )
-  };
-  const workflows = definition.workflows === void 0 ? {} : {
-    workflows: Object.fromEntries(
-      Object.entries(definition.workflows).map(([name, value]) => {
-        const declared2 = nativeWorkflow(value);
-        if (declared2 === void 0) throw new Error("Invalid workflow declaration");
-        return [name, declared2];
-      })
-    )
-  };
-  const root = definition.tools === void 0 ? void 0 : nativeRouter(definition.tools);
-  if (definition.tools !== void 0 && root === void 0)
-    throw new Error("tools must be a router");
-  const data = root === void 0 ? {} : { tools: root };
-  const declared = root?.kind === "router" ? declaredOperations(root) : [];
-  const mutations = /* @__PURE__ */ new Set();
-  for (const { operation } of declared) {
-    if (operation.kind !== "mutation") continue;
-    if (mutations.has(operation))
-      throw new Error("A mutation can be mounted at only one path in tools");
-    mutations.add(operation);
-  }
-  const schedules = definition.schedules === void 0 ? {} : {
-    schedules: Object.fromEntries(
-      Object.entries(definition.schedules).map(([name, schedule]) => {
-        const target = nativeOperation(schedule.operation);
-        const match = declared.find(
-          ({ operation }) => operation === target && operation.kind === "mutation"
-        );
-        if (match === void 0)
-          throw new Error("A schedule must reference a mutation in this app's tools");
-        return [
-          name,
-          {
-            timing: Schema_exports.decodeUnknownSync(ScheduleTiming)(schedule.timing),
-            input: Schema_exports.decodeUnknownSync(JsonValue)(schedule.input),
-            tool: match.name
-          }
-        ];
-      })
-    )
-  };
-  return {
-    ...definition,
-    ...webhooks,
-    ...workflows,
-    ...data,
-    ...schedules
-  };
-}
-var defineApp = (requirements, definition) => {
-  if (typeof definition !== "function") rejectCatalogs(definition);
-  const evaluate = typeof definition === "function" ? definition : async () => definition;
-  const factory = fromPromise(evaluate);
-  const native = {
-    accounts: requirements.accounts,
-    ...requirements.database === void 0 ? {} : { database: requirements.database },
-    evaluate: (context) => factory(context).pipe(Effect_exports.map((value) => adaptDefinition(value)))
-  };
-  return {
-    [InternalApp]: native,
-    accounts: native.accounts,
-    evaluate: (context) => Effect_exports.runPromise(factory(context))
-  };
-};
-
-// src/implementation/storage.ts
-var table = (fields) => tableWithIndexes(fields, []);
-var tableWithIndexes = (fields, indexes) => ({
-  fields,
-  indexes,
-  index: (name, fieldsInIndex) => tableWithIndexes(fields, [...indexes, { name, fields: fieldsInIndex }])
-});
-var serialize = (tables) => {
-  const definitions = Object.fromEntries(
-    Object.entries(tables).map(([name, table2]) => [
-      name,
-      {
-        fields: Object.fromEntries(
-          Object.entries(table2.fields).map(([fieldName, schema]) => {
-            const field = storageFieldOf(schema);
-            if (field === void 0) throw new Error("Database columns must use a scalar schema");
-            return [fieldName, field];
-          })
-        ),
-        indexes: table2.indexes
-      }
-    ])
-  );
-  return Schema_exports.decodeUnknownSync(DatabaseSchema)(definitions);
-};
-var authorDatabase = (tables, session, signal, writable) => {
-  return Object.fromEntries(
-    Object.entries(tables).map(([name, table2]) => {
-      const api = promiseTable(session, name, signal);
-      const parseFields = (input, partial) => {
-        const values = Schema_exports.decodeUnknownSync(
-          Schema_exports.Record(Schema_exports.String, Schema_exports.Unknown)
-        )(input);
-        const fields = {};
-        for (const [key, value] of Object.entries(values)) {
-          if (value === void 0) continue;
-          const field = Object.hasOwn(table2.fields, key) ? table2.fields[key] : void 0;
-          if (field === void 0) throw new Error("Unknown database column");
-          const definition = storageFieldOf(field);
-          fields[key] = value === null && definition?.optional ? null : field.parse(value);
-        }
-        if (!partial) {
-          for (const [key, field] of Object.entries(table2.fields))
-            if (!Object.hasOwn(fields, key)) {
-              const value = field.parse(void 0);
-              if (value !== void 0) fields[key] = value;
-            }
-        }
-        return fields;
-      };
-      const read = { get: api.get, withIndex: api.withIndex };
-      return [
-        name,
-        writable ? {
-          ...read,
-          insert: (value) => api.insert(parseFields(value, false)),
-          update: (id, value) => api.update(id, parseFields(value, true)),
-          delete: api.delete
-        } : read
-      ];
-    })
-  );
-};
-var defineDatabase = (tables) => ({
-  schema: serialize(tables),
-  tables
-});
-var unavailableStorage = {
-  read: () => Effect_exports.fail(new AppStorageUnavailable()),
-  mutate: () => Effect_exports.fail(new AppStorageUnavailable())
-};
-
-export {
-  ResponseStatusError,
-  ResponseDecodeError,
-  workflow,
-  isApp,
-  toEffectApp,
-  defineApp,
-  table,
-  authorDatabase,
-  defineDatabase,
-  unavailableStorage
-};