runtime_server library

Prisma Flutter Connector - Server Runtime Library

This library provides the runtime components for pure Dart server environments (Dart Frog, Shelf, etc.) without Flutter dependencies.

Use this instead of runtime.dart when:

Building Dart Frog backends
Building Shelf/Alfred servers
Any pure Dart server environment

Use runtime.dart when:

Building Flutter mobile/web apps
Need SQLite support for offline-first mobile apps

Why This Exists

The main runtime.dart exports the SQLite adapter which depends on sqflite, a Flutter plugin that imports dart:ui. This causes compilation errors in pure Dart environments where Flutter SDK is not available.

This library exports only the PostgreSQL and Supabase adapters which use the pure Dart postgres package.

Supported Databases

PostgreSQL via postgres package
Supabase (PostgreSQL with direct connection)

Usage

// In your Dart Frog backend:
import 'package:prisma_flutter_connector/runtime_server.dart';
import 'package:postgres/postgres.dart' as pg;

// Connect to database
final connection = await pg.Connection.open(
  pg.Endpoint(
    host: 'localhost',
    database: 'mydb',
    username: 'user',
    password: 'password',
  ),
);

// Create adapter
final adapter = PostgresAdapter(connection);
final executor = QueryExecutor(adapter: adapter);

// Build and execute query
final query = JsonQueryBuilder()
    .model('User')
    .action(QueryAction.findMany)
    .where({'email': FilterOperators.contains('@example.com')})
    .orderBy({'createdAt': 'desc'})
    .build();

final users = await executor.executeQueryAsMaps(query);
print('Found ${users.length} users');

Supabase Connection

final adapter = await SupabaseAdapter.fromConnectionString(
  'postgresql://user:pass@host:6543/db?pgbouncer=true',
);
final executor = QueryExecutor(adapter: adapter);

Transactions

await executor.executeInTransaction((tx) async {
  await tx.executeMutation(createUserQuery);
  await tx.executeMutation(createProfileQuery);
  // Both succeed or both rollback
});

Classes

BaseExecutor: Abstract base class for query execution.
ColumnAlias: Alias information for a column.
CompiledRelations: Compiled result containing JOIN clauses and column selection.
CompositeQueryLogger: A composite logger that delegates to multiple loggers.
ConnectionInfo: Connection information for a database.
ConsoleQueryLogger: A query logger that prints to the console.
FieldInfo: Information about a model field.
FilterOperators: Filter operators for WHERE clauses.
IncludedRelation: Information about an included relation.
JsonFieldSelection: Selection for a specific field.
JsonQuery: Represents a complete JSON query in Prisma's format.
JsonQueryArgs: Arguments for a JSON query.
JsonQueryBuilder: Builder for constructing JSON queries.
JsonSelection: Field selection in a query.
MetricsQueryLogger: A query logger that collects metrics.
ModelSchema: Schema definition for a Prisma model.
NoOpQueryLogger: A logger that does nothing.
PostgresAdapter: PostgreSQL database adapter.
PostgresTransaction: PostgreSQL transaction implementation.
PrismaErrorMapper: Maps database-specific error codes to PrismaException types.
PrismaValue: Special Prisma value types (DateTime, Json, Bytes, etc.).
QueryEndEvent: Event data for a completed query.
QueryErrorEvent: Event data for a failed query.
QueryExecutor: Executes Prisma queries against a database adapter.
QueryLogger: Interface for query logging.
QueryMetric: A single query execution metric.
QueryStartEvent: Event data for a query that is about to be executed.
RelationCompiler: Compiles Prisma include/select into SQL JOINs.
RelationDeserializer: Deserializes flat JOIN results into nested objects.
RelationInfo: Information about a relation between models.
RelationMetadata: Marker interface for relation metadata used in JOIN queries.
SchemaRegistry: Registry that stores model schemas and provides lookup methods.
SqlCompiler: Compiles JSON queries to SQL.
SqlDriverAdapter: Main database adapter interface.
SqlQuery: Represents a SQL query with parameterized values and type information.
SqlQueryable: Interface for executing SQL queries (implemented by adapters and transactions).
SqlResultSet: Result set from a SQL query execution.
SupabaseAdapter: Supabase database adapter using direct PostgreSQL connection.
Transaction: Abstract interface for database transactions.
TransactionExecutor: Query executor for use within transactions.

Enums

ArgType: Type information for query arguments.
ColumnType: Column type information for result set columns.
IsolationLevel: Transaction isolation levels.
QueryAction: Query action types (matching Prisma's actions).
RelationType: Types of relations between models.

Extensions

SchemaRegistryBuilder on SchemaRegistry: Extension methods for building relation metadata.

Properties

schemaRegistry → SchemaRegistry: Global schema registry instance.
final

Exceptions / Errors

AdapterError: Error thrown by database adapters.
AuthenticationException: Authentication failed.
ConnectionException: Database connection failed.
ConnectionTimeoutException: Connection timed out.
ConstraintException: Constraint violation (general).
ForeignKeyException: Foreign key constraint violation.
InternalException: Internal query engine error.
InvalidFieldValueException: Invalid field value.
PrismaException: Base class for all Prisma exceptions.
QueryTimeoutException: Query timeout.
RecordNotFoundException: Record not found.
RelatedRecordNotFoundException: Related record not found.
RequiredFieldException: Required value missing.
TransactionException: Transaction failed.
UniqueConstraintException: Unique constraint violation.
UnsupportedOperationException: Unsupported operation.