apps 0.0.1-beta.0

package/js/storage/facet.js

@@ -0,0 +1,546 @@
+import {
+  SqlClient,
+  defaultTransforms,
+  layer,
+  make as make3,
+  makeCompilerSqlite
+} from "../chunk-D6BKYP2L.js";
+import {
+  makeSqliteDatabase
+} from "../chunk-R6JMJSVT.js";
+import "../chunk-7JXHF5IF.js";
+import {
+  Defect,
+  Effect_exports,
+  Scope,
+  Semaphore_exports,
+  Service,
+  String,
+  TaggedError2 as TaggedError,
+  Union,
+  add,
+  addFinalizer,
+  as,
+  asVoid,
+  assignProperty2 as assignProperty,
+  callback,
+  catchCauseFilter2 as catchCauseFilter,
+  die,
+  effectContext,
+  fail3 as fail,
+  fail4 as fail2,
+  fail5 as fail3,
+  findDefect,
+  flatten,
+  fromIteratorSucceed,
+  gen,
+  getCurrent,
+  getOption,
+  getUnsafe,
+  hasProperty,
+  identity,
+  isFailure2 as isFailure,
+  make,
+  make5 as make2,
+  map3 as map,
+  mapArray,
+  onExit,
+  optional,
+  promise,
+  provide2 as provide,
+  provideContext,
+  succeed4 as succeed,
+  suspend,
+  suspend2,
+  tap,
+  try_2 as try_,
+  uninterruptibleMask,
+  void_,
+  withFiber
+} from "../chunk-2OTCEKL2.js";
+import "../chunk-MLKGABMK.js";
+
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/sql/SqlError.js
+var TypeId = "~effect/sql/SqlError";
+var ReasonTypeId = "~effect/sql/SqlError/Reason";
+var ReasonFields = {
+  cause: /* @__PURE__ */ Defect(),
+  message: /* @__PURE__ */ optional(String),
+  operation: /* @__PURE__ */ optional(String)
+};
+var ConnectionError = class extends (/* @__PURE__ */ TaggedError("effect/sql/SqlError/ConnectionError")("ConnectionError", ReasonFields)) {
+  /**
+   * Marks this value as a structured SQL error reason for runtime guards.
+   *
+   * @since 4.0.0
+   */
+  [ReasonTypeId] = ReasonTypeId;
+  /**
+   * Indicates whether retrying the failed SQL operation may succeed.
+   *
+   * @since 4.0.0
+   */
+  get isRetryable() {
+    return true;
+  }
+};
+var AuthenticationError = class extends (/* @__PURE__ */ TaggedError("effect/sql/SqlError/AuthenticationError")("AuthenticationError", ReasonFields)) {
+  /**
+   * Marks this value as a structured SQL error reason for runtime guards.
+   *
+   * @since 4.0.0
+   */
+  [ReasonTypeId] = ReasonTypeId;
+  /**
+   * Indicates whether retrying the failed SQL operation may succeed.
+   *
+   * @since 4.0.0
+   */
+  get isRetryable() {
+    return false;
+  }
+};
+var AuthorizationError = class extends (/* @__PURE__ */ TaggedError("effect/sql/SqlError/AuthorizationError")("AuthorizationError", ReasonFields)) {
+  /**
+   * Marks this value as a structured SQL error reason for runtime guards.
+   *
+   * @since 4.0.0
+   */
+  [ReasonTypeId] = ReasonTypeId;
+  /**
+   * Indicates whether retrying the failed SQL operation may succeed.
+   *
+   * @since 4.0.0
+   */
+  get isRetryable() {
+    return false;
+  }
+};
+var SqlSyntaxError = class extends (/* @__PURE__ */ TaggedError("effect/sql/SqlError/SqlSyntaxError")("SqlSyntaxError", ReasonFields)) {
+  /**
+   * Marks this value as a structured SQL error reason for runtime guards.
+   *
+   * @since 4.0.0
+   */
+  [ReasonTypeId] = ReasonTypeId;
+  /**
+   * Indicates whether retrying the failed SQL operation may succeed.
+   *
+   * @since 4.0.0
+   */
+  get isRetryable() {
+    return false;
+  }
+};
+var UniqueViolationFields = {
+  ...ReasonFields,
+  constraint: String
+};
+var UniqueViolation = class extends (/* @__PURE__ */ TaggedError("effect/sql/SqlError/UniqueViolation")("UniqueViolation", UniqueViolationFields)) {
+  /**
+   * Marks this value as a structured SQL error reason for runtime guards.
+   *
+   * @since 4.0.0
+   */
+  [ReasonTypeId] = ReasonTypeId;
+  /**
+   * Indicates whether retrying the failed SQL operation may succeed.
+   *
+   * @since 4.0.0
+   */
+  get isRetryable() {
+    return false;
+  }
+};
+var ConstraintError = class extends (/* @__PURE__ */ TaggedError("effect/sql/SqlError/ConstraintError")("ConstraintError", ReasonFields)) {
+  /**
+   * Marks this value as a structured SQL error reason for runtime guards.
+   *
+   * @since 4.0.0
+   */
+  [ReasonTypeId] = ReasonTypeId;
+  /**
+   * Indicates whether retrying the failed SQL operation may succeed.
+   *
+   * @since 4.0.0
+   */
+  get isRetryable() {
+    return false;
+  }
+};
+var DeadlockError = class extends (/* @__PURE__ */ TaggedError("effect/sql/SqlError/DeadlockError")("DeadlockError", ReasonFields)) {
+  /**
+   * Marks this value as a structured SQL error reason for runtime guards.
+   *
+   * @since 4.0.0
+   */
+  [ReasonTypeId] = ReasonTypeId;
+  /**
+   * Indicates whether retrying the failed SQL operation may succeed.
+   *
+   * @since 4.0.0
+   */
+  get isRetryable() {
+    return true;
+  }
+};
+var SerializationError = class extends (/* @__PURE__ */ TaggedError("effect/sql/SqlError/SerializationError")("SerializationError", ReasonFields)) {
+  /**
+   * Marks this value as a structured SQL error reason for runtime guards.
+   *
+   * @since 4.0.0
+   */
+  [ReasonTypeId] = ReasonTypeId;
+  /**
+   * Indicates whether retrying the failed SQL operation may succeed.
+   *
+   * @since 4.0.0
+   */
+  get isRetryable() {
+    return true;
+  }
+};
+var LockTimeoutError = class extends (/* @__PURE__ */ TaggedError("effect/sql/SqlError/LockTimeoutError")("LockTimeoutError", ReasonFields)) {
+  /**
+   * Marks this value as a structured SQL error reason for runtime guards.
+   *
+   * @since 4.0.0
+   */
+  [ReasonTypeId] = ReasonTypeId;
+  /**
+   * Indicates whether retrying the failed SQL operation may succeed.
+   *
+   * @since 4.0.0
+   */
+  get isRetryable() {
+    return true;
+  }
+};
+var StatementTimeoutError = class extends (/* @__PURE__ */ TaggedError("effect/sql/SqlError/StatementTimeoutError")("StatementTimeoutError", ReasonFields)) {
+  /**
+   * Marks this value as a structured SQL error reason for runtime guards.
+   *
+   * @since 4.0.0
+   */
+  [ReasonTypeId] = ReasonTypeId;
+  /**
+   * Indicates whether retrying the failed SQL operation may succeed.
+   *
+   * @since 4.0.0
+   */
+  get isRetryable() {
+    return true;
+  }
+};
+var UnknownError = class extends (/* @__PURE__ */ TaggedError("effect/sql/SqlError/UnknownError")("UnknownError", ReasonFields)) {
+  /**
+   * Marks this value as a structured SQL error reason for runtime guards.
+   *
+   * @since 4.0.0
+   */
+  [ReasonTypeId] = ReasonTypeId;
+  /**
+   * Indicates whether retrying the failed SQL operation may succeed.
+   *
+   * @since 4.0.0
+   */
+  get isRetryable() {
+    return false;
+  }
+};
+var SqlErrorReason = /* @__PURE__ */ Union([ConnectionError, AuthenticationError, AuthorizationError, SqlSyntaxError, UniqueViolation, ConstraintError, DeadlockError, SerializationError, LockTimeoutError, StatementTimeoutError, UnknownError]);
+var SqlError = class extends (/* @__PURE__ */ TaggedError("effect/sql/SqlError")("SqlError", {
+  reason: SqlErrorReason
+})) {
+  /**
+   * Marks this value as the top-level SQL error wrapper for runtime guards.
+   *
+   * @since 4.0.0
+   */
+  [TypeId] = TypeId;
+  /**
+   * Exposes the structured SQL reason as the JavaScript error cause.
+   *
+   * @since 4.0.0
+   */
+  cause = this.reason;
+  /**
+   * Uses the reason message when present, otherwise falls back to the reason tag.
+   *
+   * @since 4.0.0
+   */
+  get message() {
+    return this.reason.message || this.reason._tag;
+  }
+  /**
+   * Delegates retryability to the underlying SQL error reason.
+   *
+   * @since 4.0.0
+   */
+  get isRetryable() {
+    return this.reason.isRetryable;
+  }
+};
+var sqliteCodeFromCause = (cause) => {
+  if (!hasProperty(cause, "code")) {
+    return void 0;
+  }
+  const code = cause.code;
+  return typeof code === "string" || typeof code === "number" ? code : void 0;
+};
+var sqliteNumericCodeFromCause = (cause) => {
+  const code = sqliteCodeFromCause(cause);
+  if (typeof code === "number") {
+    return code;
+  }
+  if (!hasProperty(cause, "errno")) {
+    return void 0;
+  }
+  const errno = cause.errno;
+  return typeof errno === "number" ? errno : void 0;
+};
+var matchesSqliteNumericCode = (cause, expected) => {
+  const code = sqliteCodeFromCause(cause);
+  if (code === expected) {
+    return true;
+  }
+  if (!hasProperty(cause, "errno")) {
+    return false;
+  }
+  return cause.errno === expected;
+};
+var matchesSqliteCode = (code, expected) => code === expected || code.startsWith(expected + "_");
+var UNKNOWN_CONSTRAINT = "unknown";
+var SQLITE_CONSTRAINT_UNIQUE = "SQLITE_CONSTRAINT_UNIQUE";
+var SQLITE_CONSTRAINT_UNIQUE_CODE = 2067;
+var normalizeConstraintIdentifier = (identifier) => {
+  if (typeof identifier !== "string") {
+    return UNKNOWN_CONSTRAINT;
+  }
+  const trimmed = identifier.trim();
+  return trimmed.length === 0 ? UNKNOWN_CONSTRAINT : trimmed;
+};
+var sqliteUniqueConstraintFromCause = (cause) => {
+  if (hasProperty(cause, "constraint")) {
+    return normalizeConstraintIdentifier(cause.constraint);
+  }
+  if (!hasProperty(cause, "message")) {
+    return UNKNOWN_CONSTRAINT;
+  }
+  const message = cause.message;
+  if (typeof message !== "string") {
+    return UNKNOWN_CONSTRAINT;
+  }
+  const prefix = "UNIQUE constraint failed:";
+  const index = message.indexOf(prefix);
+  return index === -1 ? UNKNOWN_CONSTRAINT : normalizeConstraintIdentifier(message.slice(index + prefix.length));
+};
+var classifySqliteError = (cause, {
+  message,
+  operation
+} = {}) => {
+  const props = {
+    cause,
+    message,
+    operation
+  };
+  const code = sqliteCodeFromCause(cause);
+  const numericCode = sqliteNumericCodeFromCause(cause);
+  if (code === SQLITE_CONSTRAINT_UNIQUE || matchesSqliteNumericCode(cause, SQLITE_CONSTRAINT_UNIQUE_CODE)) {
+    return new UniqueViolation({
+      ...props,
+      constraint: sqliteUniqueConstraintFromCause(cause)
+    });
+  }
+  if (typeof code === "string") {
+    if (matchesSqliteCode(code, "SQLITE_AUTH")) {
+      return new AuthenticationError(props);
+    }
+    if (matchesSqliteCode(code, "SQLITE_PERM")) {
+      return new AuthorizationError(props);
+    }
+    if (matchesSqliteCode(code, "SQLITE_CONSTRAINT")) {
+      return new ConstraintError(props);
+    }
+    if (matchesSqliteCode(code, "SQLITE_BUSY") || matchesSqliteCode(code, "SQLITE_LOCKED")) {
+      return new LockTimeoutError(props);
+    }
+    if (matchesSqliteCode(code, "SQLITE_CANTOPEN")) {
+      return new ConnectionError(props);
+    }
+  }
+  if (typeof numericCode === "number") {
+    const code2 = numericCode & 255;
+    switch (code2) {
+      case 23:
+        return new AuthenticationError(props);
+      case 3:
+        return new AuthorizationError(props);
+      case 19:
+        return new ConstraintError(props);
+      case 5:
+      case 6:
+        return new LockTimeoutError(props);
+      case 14:
+        return new ConnectionError(props);
+      default:
+        return new UnknownError(props);
+    }
+  }
+  return new UnknownError(props);
+};
+
+// ../../node_modules/.bun/@effect+sql-sqlite-do@https+++pkg.pr.new+Effect-TS+effect+@effect+sql-sqlite-do@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d+e4138e778cda3d8b/node_modules/@effect/sql-sqlite-do/dist/SqliteClient.js
+var ATTR_DB_SYSTEM_NAME = "db.system.name";
+var classifyError = (cause, message, operation) => classifySqliteError(cause, {
+  message,
+  operation
+});
+var TypeId2 = "~@effect/sql-sqlite-do/SqliteClient";
+var SqliteClient = /* @__PURE__ */ Service("@effect/sql-sqlite-do/SqliteClient");
+var SqliteTransaction = /* @__PURE__ */ Service("@effect/sql-sqlite-do/SqliteClient/SqliteTransaction");
+var unsupportedTransaction = (message, operation) => new SqlError({
+  reason: new UnknownError({
+    cause: new Error(message),
+    message,
+    operation
+  })
+});
+var makeUnsupportedWithTransaction = (message) => (_effect) => fail2(unsupportedTransaction(message, "transaction"));
+var makeStorageBackedWithTransaction = (storage, connection, semaphore) => (effect) => withFiber((fiber) => {
+  const services = fiber.context;
+  const connOption = getOption(services, SqliteTransaction);
+  if (connOption._tag === "Some" && connOption.value[0] !== connection) {
+    return fail2(unsupportedTransaction("Transactions cannot use a connection from a different SQLite client", "transaction"));
+  }
+  const depth = connOption._tag === "Some" ? connOption.value[1] + 1 : 0;
+  const effectWithTxn = provideContext(effect, add(services, SqliteTransaction, [connection, depth]));
+  const transaction = callback((resume) => {
+    let interrupted = false;
+    const promise2 = storage.transaction((txn) => new Promise((resolve) => {
+      if (interrupted) return resolve();
+      resume(onExit(effectWithTxn, (exit) => {
+        if (isFailure(exit)) {
+          txn.rollback();
+        }
+        resolve();
+        return flatten(promise(() => promise2));
+      }));
+    })).then(() => void_, (cause) => {
+      const exit = fail(new SqlError({
+        reason: classifyError(cause, "Failed transaction", "transaction")
+      }));
+      resume(exit);
+      return exit;
+    });
+    return suspend(() => {
+      interrupted = true;
+      return asVoid(promise(() => promise2));
+    });
+  });
+  return connOption._tag === "Some" ? transaction : semaphore.withPermits(1)(transaction);
+});
+var make4 = (options) => gen(function* () {
+  const compiler = makeCompilerSqlite(options.transformQueryNames);
+  const transformRows = options.transformResultNames ? defaultTransforms(options.transformResultNames).array : void 0;
+  const db = options.storage?.sql ?? options.db;
+  if (db === void 0) {
+    return yield* die("SqliteClient.make requires either a Durable Object storage or sql storage");
+  }
+  const sqlStorage = db;
+  const makeConnection = gen(function* () {
+    function* runIterator(sql, params = []) {
+      const cursor = sqlStorage.exec(sql, ...params);
+      const columns = cursor.columnNames;
+      for (const result of cursor.raw()) {
+        const obj = {};
+        for (let i = 0; i < columns.length; i++) {
+          const value = result[i];
+          assignProperty(obj, columns[i], value instanceof ArrayBuffer ? new Uint8Array(value) : value);
+        }
+        yield obj;
+      }
+    }
+    const runStatement = (sql, params = []) => try_({
+      try: () => Array.from(runIterator(sql, params)),
+      catch: (cause) => new SqlError({
+        reason: classifyError(cause, "Failed to execute statement", "execute")
+      })
+    });
+    const runValues = (sql, params = []) => try_({
+      try: () => Array.from(sqlStorage.exec(sql, ...params).raw(), (row) => {
+        for (let i = 0; i < row.length; i++) {
+          const value = row[i];
+          if (value instanceof ArrayBuffer) {
+            row[i] = new Uint8Array(value);
+          }
+        }
+        return row;
+      }),
+      catch: (cause) => new SqlError({
+        reason: classifyError(cause, "Failed to execute statement", "execute")
+      })
+    });
+    return identity({
+      execute(sql, params, transformRows2) {
+        return transformRows2 ? map(runStatement(sql, params), transformRows2) : runStatement(sql, params);
+      },
+      executeRaw(sql, params) {
+        return runStatement(sql, params);
+      },
+      executeValues(sql, params) {
+        return runValues(sql, params);
+      },
+      executeValuesUnprepared(sql, params) {
+        return runValues(sql, params);
+      },
+      executeUnprepared(sql, params, transformRows2) {
+        return transformRows2 ? map(runStatement(sql, params), transformRows2) : runStatement(sql, params);
+      },
+      executeStream(sql, params, transformRows2) {
+        return suspend2(() => {
+          const iterator = runIterator(sql, params);
+          return fromIteratorSucceed(iterator, 128);
+        }).pipe(catchCauseFilter(findDefect, (defect) => fail3(new SqlError({
+          reason: classifyError(defect, "Failed to execute statement", "execute")
+        }))), transformRows2 ? mapArray((chunk) => transformRows2(chunk)) : identity);
+      }
+    });
+  });
+  const semaphore = yield* make2(1);
+  const connection = yield* makeConnection;
+  const acquirer = semaphore.withPermits(1)(succeed(connection));
+  const transactionAcquirer = uninterruptibleMask((restore) => {
+    const fiber = getCurrent();
+    const scope = getUnsafe(fiber.context, Scope);
+    return as(tap(restore(semaphore.take(1)), () => addFinalizer(scope, semaphore.release(1))), connection);
+  });
+  const client = yield* make3({
+    acquirer,
+    compiler,
+    transactionAcquirer,
+    transactionService: SqliteTransaction,
+    spanAttributes: [...options.spanAttributes ? Object.entries(options.spanAttributes) : [], [ATTR_DB_SYSTEM_NAME, "sqlite"]],
+    transformRows
+  });
+  return Object.assign(client, {
+    [TypeId2]: TypeId2,
+    config: options,
+    withTransaction: options.storage ? makeStorageBackedWithTransaction(options.storage, connection, semaphore) : makeUnsupportedWithTransaction("Transactions require Durable Object storage; pass ctx.storage as the storage option")
+  });
+});
+var layer2 = (config) => effectContext(map(make4(config), (client) => make(SqliteClient, client).pipe(add(SqlClient, client)))).pipe(provide(layer));
+
+// src/facet.ts
+var facetStorage = (storage) => {
+  const transactions = Semaphore_exports.makeUnsafe(1);
+  const run = (write) => (schema, work) => Effect_exports.gen(function* () {
+    const sql = yield* SqlClient;
+    const database = yield* makeSqliteDatabase({ sql, schema, crypto });
+    return yield* database[write ? "mutate" : "read"](work);
+  }).pipe(Effect_exports.provide(layer2({ storage })), transactions.withPermits(1));
+  return { read: run(false), mutate: run(true) };
+};
+export {
+  facetStorage
+};

package/js/ui/auth/contracts.js

@@ -0,0 +1,19 @@
+import {
+  AppReturnPath,
+  AppSignInApi,
+  AppSignInCallback,
+  AppSignInCode,
+  AppSignInId
+} from "../../chunk-SBKHUC5L.js";
+import "../../chunk-3ANFZFCV.js";
+import "../../chunk-W7Q5EOTS.js";
+import "../../chunk-36DNRFZQ.js";
+import "../../chunk-2OTCEKL2.js";
+import "../../chunk-MLKGABMK.js";
+export {
+  AppReturnPath,
+  AppSignInApi,
+  AppSignInCallback,
+  AppSignInCode,
+  AppSignInId
+};

package/js/ui/auth.js

@@ -0,0 +1,28 @@
+import {
+  appPrivateHeaders,
+  appSignInPage,
+  appSignInScript
+} from "../chunk-BKVL7XAJ.js";
+import {
+  AppReturnPath,
+  AppSignInApi,
+  AppSignInCallback,
+  AppSignInCode,
+  AppSignInId
+} from "../chunk-SBKHUC5L.js";
+import "../chunk-3ANFZFCV.js";
+import "../chunk-VFUZI3NY.js";
+import "../chunk-W7Q5EOTS.js";
+import "../chunk-36DNRFZQ.js";
+import "../chunk-2OTCEKL2.js";
+import "../chunk-MLKGABMK.js";
+export {
+  AppReturnPath,
+  AppSignInApi,
+  AppSignInCallback,
+  AppSignInCode,
+  AppSignInId,
+  appPrivateHeaders,
+  appSignInPage,
+  appSignInScript
+};

package/js/ui/contracts.js

@@ -0,0 +1,24 @@
+import {
+  AppUiApi,
+  UiContext,
+  UiDeploymentChanged,
+  UiFailed,
+  UiForbidden,
+  UiOperation,
+  UiSnapshot,
+  UiUnauthorized
+} from "../chunk-3ANFZFCV.js";
+import "../chunk-W7Q5EOTS.js";
+import "../chunk-36DNRFZQ.js";
+import "../chunk-2OTCEKL2.js";
+import "../chunk-MLKGABMK.js";
+export {
+  AppUiApi,
+  UiContext,
+  UiDeploymentChanged,
+  UiFailed,
+  UiForbidden,
+  UiOperation,
+  UiSnapshot,
+  UiUnauthorized
+};