apps 0.0.1-beta.7 → 0.0.1-beta.73

package/types/app-data/src/implementation/promise.d.ts

@@ -1,68 +0,0 @@
-import { Row, type DatabaseSession } from "../contracts/database.js";
-/** Index predicates are accumulated immutably, then checked against the declaration by the engine. */
-export interface IndexRange<Fields> {
-    /** Constrain an index prefix field to one value. Null matches a cleared optional field. */
-    readonly eq: <Key extends keyof Fields & string>(field: Key, value: Fields[Key] | null) => IndexRange<Fields>;
-    /** Require a value greater than the bound on the next index field. */
-    readonly gt: <Key extends keyof Fields & string>(field: Key, value: Fields[Key]) => IndexRange<Fields>;
-    /** Require a value greater than or equal to the bound on the next index field. */
-    readonly gte: <Key extends keyof Fields & string>(field: Key, value: Fields[Key]) => IndexRange<Fields>;
-    /** Require a value less than the bound on the next index field. */
-    readonly lt: <Key extends keyof Fields & string>(field: Key, value: Fields[Key]) => IndexRange<Fields>;
-    /** Require a value less than or equal to the bound on the next index field. */
-    readonly lte: <Key extends keyof Fields & string>(field: Key, value: Fields[Key]) => IndexRange<Fields>;
-}
-/** Bounded indexed reads; collect/count reject work beyond the invocation budget. */
-export interface Query<Row> {
-    /** Choose ascending or descending index order without changing this query. */
-    readonly order: (direction: "asc" | "desc") => Query<Row>;
-    /** Read all matching rows within the invocation budget; exceeding it fails. */
-    readonly collect: () => Promise<readonly Row[]>;
-    /** Count matching rows within the scan budget; exceeding it fails. */
-    readonly count: () => Promise<number>;
-    /** Read the first matching row, or null when no row matches. */
-    readonly first: () => Promise<Row | null>;
-    /** Read at most count matching rows within the invocation budget. */
-    readonly take: (count: number) => Promise<readonly Row[]>;
-    /** Read one cursor page. Return its rows, continuation cursor and completion flag. */
-    readonly paginate: (options: {
-        readonly numItems: number;
-        readonly cursor: string | null;
-    }) => Promise<{
-        readonly page: readonly Row[];
-        readonly continueCursor: string | null;
-        readonly isDone: boolean;
-    }>;
-}
-/** Typed table operations exposed to authored queries. */
-export interface ReadTable<Row, Index extends string = string> {
-    /** Read a complete row by ID, or null when it does not exist. */
-    readonly get: (id: string) => Promise<Row | null>;
-    /** Select a declared index or by_creation, with optional prefix and range constraints. */
-    readonly withIndex: (index: Index | "by_creation", range?: (query: IndexRange<Row>) => IndexRange<Row>) => Query<Row>;
-}
-/** Writes are valid only inside their owning mutation. */
-export interface WriteTable<Row, Insert, Index extends string = string> extends ReadTable<Row, Index> {
-    /** Insert authored fields and return the complete row with generated id, createdAt and updatedAt. */
-    readonly insert: (value: Insert) => Promise<Row>;
-    /** Patch authored fields and return the complete row, or null if the ID does not exist. */
-    readonly update: (id: string, patch: Partial<Insert>) => Promise<Row | null>;
-    /** Delete the row and return whether it existed. */
-    readonly delete: (id: string) => Promise<boolean>;
-}
-/** Build an untyped transport facade; the author schema layer installs exact field and row decoders. */
-export declare const promiseTable: (session: DatabaseSession, table: string, signal: AbortSignal) => {
-    get: (id: string) => Promise<{
-        readonly [x: string]: string | number | boolean;
-    } | null>;
-    insert: (value: unknown) => Promise<{
-        readonly [x: string]: string | number | boolean;
-    }>;
-    update: (id: string, patch: unknown) => Promise<{
-        readonly [x: string]: string | number | boolean;
-    } | null>;
-    delete: (id: string) => Promise<boolean>;
-    withIndex: (index: string, range?: (query: IndexRange<Row>) => IndexRange<Row>) => Query<{
-        readonly [x: string]: string | number | boolean;
-    }>;
-};

package/types/app-data/src/implementation/range.d.ts

@@ -1,8 +0,0 @@
-/** Index-prefix equality followed by at most one field's lower and upper bounds. */
-import { Effect } from "effect";
-import { AppDatabaseError, type QueryPlan, type Table } from "../contracts/database.js";
-/** Produce half-open BLOB bounds; absent optional values do not satisfy ordinary range predicates. */
-export declare const queryBounds: (table: Table, plan: QueryPlan, maximum: number) => Effect.Effect<{
-    lower: Uint8Array<ArrayBufferLike>;
-    upper: Uint8Array<ArrayBufferLike> | undefined;
-}, AppDatabaseError, never>;

package/types/app-data/src/implementation/schema.d.ts

@@ -1,18 +0,0 @@
-/** Validate declarations and write values before touching SQLite. */
-import { Effect } from "effect";
-import { AppDatabaseError, DatabaseFieldReserved, DatabaseSchema, RowMetadata, type Field, type Row, type Scalar, type Table } from "../contracts/database.js";
-/** Built-in creation ordering and stable tie-breakers apply to every index. */
-export declare const indexesFor: (table: Table) => {
-    name: string;
-    fields: string[];
-}[];
-/** Metadata fields have stable string semantics and cannot be overwritten. */
-export declare const fieldFor: (table: Table, name: string) => Field | undefined;
-/** Finite numbers and well-formed strings keep JSON and index ordering consistent. */
-export declare const validScalar: (field: Field, value: unknown) => value is Scalar;
-/** Parse the whole schema, including references and composite-index definitions. */
-export declare const parseDatabaseSchema: (input: unknown) => Effect.Effect<DatabaseSchema, AppDatabaseError | DatabaseFieldReserved>;
-/** Canonical ordering for schema fingerprints and query-bound cursors. */
-export declare const canonicalSchema: (schema: DatabaseSchema) => string;
-/** Inserts apply declared defaults; updates reject unknown/metadata fields and clear optional values with null. */
-export declare const writeValue: (table: Table, values: Readonly<Record<string, Scalar | null>>, previous: Row | undefined, meta: typeof RowMetadata.Type) => Effect.Effect<Record<string, string | number | boolean>, AppDatabaseError, never>;

package/types/app-data/src/implementation/sqlite.d.ts

@@ -1,11 +0,0 @@
-/** Shared SQLite engine. Drivers, persistent paths and app ownership belong to the host. */
-import { Effect } from "effect";
-import type { SqlClient } from "effect/unstable/sql/SqlClient";
-import { AppDatabaseError, DatabaseLimits, type AppDatabase } from "../contracts/database.js";
-/** Open a database whose storage is owned by exactly one configured app. Schema changes fail closed. */
-export declare const makeSqliteDatabase: (options: {
-    readonly sql: SqlClient;
-    readonly schema: unknown;
-    readonly crypto: Crypto;
-    readonly limits?: DatabaseLimits;
-}) => Effect.Effect<AppDatabase, AppDatabaseError>;

package/types/app-data/src/index.d.ts

@@ -1,4 +0,0 @@
-/** Portable, app-owned database engine and contracts. */
-export * from "./contracts/database.js";
-export { makeSqliteDatabase } from "./implementation/sqlite.js";
-export { promiseTable, type IndexRange, type Query, type ReadTable, type WriteTable, } from "./implementation/promise.js";

package/types/apps/src/contracts/storage.d.ts

@@ -1,68 +0,0 @@
-/** Native app data boundary. Hosts bind a configured app before exposing this capability. */
-import { Schema, type Effect } from "effect";
-import type { RowMetadata, ReadTable, WriteTable } from "../../../app-data/src/index.js";
-import type { Fields, ObjectValue } from "../implementation/schema.js";
-import type { DatabaseSchema, DatabaseSession, DatabaseError } from "../../../app-data/src/contracts/database.js";
-/** Names for authored operations and tables. */
-export declare const StorageName: Schema.NonEmptyString;
-declare const AppStorageUnavailable_base: Schema.Class<AppStorageUnavailable, Schema.TaggedStruct<"AppStorageUnavailable", {}>, import("effect/Cause").YieldableError>;
-/** Storage is not configured on this host. */
-export declare class AppStorageUnavailable extends AppStorageUnavailable_base {
-}
-declare const AppStorageError_base: Schema.Class<AppStorageError, Schema.TaggedStruct<"AppStorageError", {}>, import("effect/Cause").YieldableError>;
-/** App storage operations never expose SQL, documents or credentials in failures. */
-export declare class AppStorageError extends AppStorageError_base {
-}
-/** The adapter owns the database connection and transaction for the whole authored invocation. */
-export interface AppStorage {
-    readonly read: <A, E>(schema: DatabaseSchema, work: (session: DatabaseSession) => Effect.Effect<A, E>) => Effect.Effect<A, E | DatabaseError | AppStorageUnavailable | AppStorageError>;
-    readonly mutate: <A, E>(schema: DatabaseSchema, work: (session: DatabaseSession) => Effect.Effect<A, E>) => Effect.Effect<A, E | DatabaseError | AppStorageUnavailable | AppStorageError>;
-}
-type InputValue<F extends Fields> = {
-    readonly [K in keyof F as F[K]["optionalValue"] extends true ? never : F[K] extends {
-        readonly hasDefault: true;
-    } ? never : K]: Exclude<import("../implementation/schema.js").Infer<F[K]>, undefined>;
-} & {
-    readonly [K in keyof F as F[K]["optionalValue"] extends true ? K : F[K] extends {
-        readonly hasDefault: true;
-    } ? K : never]?: Exclude<import("../implementation/schema.js").Infer<F[K]>, undefined> | (F[K]["optionalValue"] extends true ? null : F[K] extends {
-        readonly inputOptional: true;
-    } ? null : never) | undefined;
-};
-/** Typed table declaration; indexes refer only to authored or host metadata fields. */
-export interface Table<F extends Fields, Index extends string = never> {
-    readonly fields: F;
-    readonly indexes: ReadonlyArray<{
-        readonly name: string;
-        readonly fields: readonly string[];
-    }>;
-    readonly index: <Name extends string>(name: Name, fields: readonly [
-        (keyof F & string) | keyof typeof RowMetadata.Type,
-        ...((keyof F & string) | keyof typeof RowMetadata.Type)[]
-    ]) => Table<F, Index | Name>;
-}
-/** Structural table catalog accepted at the author boundary. */
-export type Tables = Readonly<Record<string, {
-    readonly fields: Fields;
-    readonly indexes: ReadonlyArray<{
-        readonly name: string;
-        readonly fields: readonly string[];
-    }>;
-}>>;
-/** Generated row metadata is read-only and unavailable on inserts. */
-export type RowOf<T extends Tables[string]> = ObjectValue<T["fields"]> & typeof RowMetadata.Type;
-type IndexOf<T> = T extends Table<Fields, infer I> ? I : string;
-/** Queries receive only read methods. */
-export type DatabaseReader<T extends Tables> = {
-    readonly [K in keyof T]: ReadTable<RowOf<T[K]>, IndexOf<T[K]>>;
-};
-/** Mutation methods stay inside one native SQLite transaction. */
-export type Database<T extends Tables> = {
-    readonly [K in keyof T]: WriteTable<RowOf<T[K]>, InputValue<T[K]["fields"]>, IndexOf<T[K]>>;
-};
-/** Pure database declaration shared by requirements and derived handler contexts. */
-export interface DatabaseDefinition<T extends Tables = Tables> {
-    readonly schema: DatabaseSchema;
-    readonly tables: T;
-}
-export {};

package/types/apps/src/implementation/storage.d.ts

@@ -1,15 +0,0 @@
-import { type DatabaseSession, type reservedFieldNames } from "../../../app-data/src/index.js";
-type ReservedFieldName = (typeof reservedFieldNames)[number];
-import { type AppStorage } from "../contracts/storage.js";
-import type { DatabaseDefinition, Database, Table, Tables } from "../contracts/storage.js";
-import { type Fields } from "./schema.js";
-export type { DatabaseDefinition, Database, DatabaseReader, Table, Tables, RowOf, } from "../contracts/storage.js";
-/** Declare scalar columns using the same schemas as operation inputs. The host adds `id`,
- * `createdAt` and `updatedAt` to every row, so tables cannot declare those names. */
-export declare const table: <const F extends Fields & { readonly [K in ReservedFieldName]?: never; }>(fields: F) => Table<F>;
-/** Build a fresh Promise database facade for one authorized invocation. */
-export declare const authorDatabase: <T extends Tables>(tables: T, session: DatabaseSession, signal: AbortSignal, writable: boolean) => Database<T>;
-/** Declare storage independently of handlers; the host binds each invocation's database. */
-export declare const defineDatabase: <const T extends Tables>(tables: T) => DatabaseDefinition<T>;
-/** Explicit missing capability, never a fallback to another app's data. */
-export declare const unavailableStorage: AppStorage;