runtime library

Prisma Flutter Connector - Runtime Library

This library provides the runtime components for the Prisma Flutter Connector, enabling direct database access from Dart/Flutter applications without requiring a GraphQL backend.

Features

Direct Database Access: Connect directly to PostgreSQL, MySQL, SQLite, and Supabase
Type-Safe Queries: Build queries using Prisma's JSON protocol
Multiple Adapters: Swap database providers easily
Transaction Support: Full ACID transaction support
Offline-First: Use SQLite adapter for mobile offline capabilities

Supported Databases

PostgreSQL via postgres package
Supabase (PostgreSQL with direct connection)
SQLite via sqflite package (mobile)
MySQL (coming soon)

Usage

import 'package:prisma_flutter_connector/runtime.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');

Database Adapters

PostgreSQL

final adapter = PostgresAdapter(connection);

Supabase

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

SQLite (Mobile)

final database = await openDatabase('app.db');
final adapter = SQLiteAdapter(database);

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.
SQLiteAdapter: SQLite database adapter for mobile apps.
SQLiteTransaction: SQLite transaction implementation.
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.