effect-postgres

19 notes, read out of this brain and free to use. Each one was extracted from a source and is re-checked against its exam.

Effect Postgres driver installation with Drizzle

To use Drizzle with Effect PostgreSQL, install the following packages: drizzle-orm@rc, effect, @effect/sql-pg, and pg. Additionally install as dev dependencies: drizzle-kit@rc and @types/pg.

PgDrizzle.makeWithDefaults() creates database instance

PgDrizzle.makeWithDefaults() quickly creates a Drizzle database instance with sensible defaults: no logging and no caching. This is an Effect-native API that integrates with Effect's service pattern.

Type parser configuration for Effect PostgreSQL

When configuring the PgClient layer with type parsers, return raw values for date/time types by checking if the typeId is in the list [1184, 1114, 1082, 1186, 1231, 1115, 1185, 1187, 1182]. This allows Drizzle to handle parsing of these types. For other type IDs, use the default types.getTypeParser() method.

Effect PostgreSQL basic query example

Example of executing a raw SQL query with Effect PostgreSQL: ```typescript import 'dotenv/config'; import * as PgDrizzle from 'drizzle-orm/effect-postgres'; import { PgClient } from '@effect/sql-pg'; import * as Effect from 'effect/Effect'; import * as Redacted from 'effect/Redacted'; import { sql } from 'drizzle-orm'; import { types } from 'pg'; const PgClientLive = PgClient.layer({ url: Redacted.make(process.env.DATABASE_URL!), types: { getTypeParser: (typeId, format) => { if ([1184, 1114, 1082, 1186, 1231, 1115, 1185, 1187, 1182].includes(typeId)) { return (val: any) => val; } return types.getTypeParser(typeId, format); }, }, }); const program = Effect.gen(function*() { const db = yield* PgDrizzle.makeWithDefaults(); const result = yield* db.execute<{ id: number }>(sql`SELECT 1 as id`); console.log(result); }); Effect.runPromise(program.pipe(Effect.provide(PgClientLive))); ```

Effect PostgreSQL dependency injection with DB layer

For larger applications, create a reusable DB layer using Effect's dependency injection pattern. Define a Context.Tag for the DB service and create a Layer.effect that provides the DB instance. Compose all layers with Layer.provideMerge(DBLive, PgClientLive) to include both the database and client layers.

PgDrizzle.make() with relations and schema

PgDrizzle.make() accepts a configuration object with options including 'relations' and 'casing'. This is used when creating a more controlled database instance with custom logger and cache configurations.

EffectLogger options for Drizzle Effect Postgres

Available logger options for Effect PostgreSQL are: EffectLogger.Default (no-op logger, no logging), EffectLogger.layer (logs queries using Effect.log() with annotations for SQL and parameters), EffectLogger.fromDrizzle(logger) (wraps a Drizzle Logger instance), and EffectLogger.layerFromDrizzle(logger) (creates an Effect Layer from a Drizzle logger).

Enable logging in Effect PostgreSQL with EffectLogger.layer

To enable logging in a Drizzle Effect Postgres instance, provide EffectLogger.layer through Effect.provide(). This logs queries using Effect's logging infrastructure with annotations for query SQL and parameters. The output format can be configured using different Effect logger layers such as Logger.pretty for development or Logger.json for production.

Wrap Drizzle logger for Effect Postgres

Example of using a Drizzle logger with Effect Postgres: ```typescript import * as PgDrizzle from 'drizzle-orm/effect-postgres'; import { EffectLogger } from 'drizzle-orm/effect-postgres'; import * as Effect from 'effect/Effect'; import { DefaultLogger } from 'drizzle-orm'; const program = Effect.gen(function*() { const db = yield* PgDrizzle.make({ /* schema, relations, casing */ }).pipe( Effect.provide(EffectLogger.layerFromDrizzle(new DefaultLogger())), Effect.provide(PgDrizzle.DefaultServices), ); const users = yield* db.select().from(usersTable); return users; }); ```

EffectCache options for Drizzle Effect Postgres

Available cache options for Effect PostgreSQL are: EffectCache.Default (no-op cache, no caching occurs, this is the default), EffectCache.fromDrizzle(cache) (wraps a Drizzle Cache instance for use with Effect), and EffectCache.layerFromDrizzle(cache) (creates an Effect Layer from a Drizzle cache for composing with other layers).

Custom cache configuration example with Effect Postgres

Example of providing a custom cache implementation with Drizzle Effect Postgres: ```typescript import * as PgDrizzle from 'drizzle-orm/effect-postgres'; import { EffectLogger } from 'drizzle-orm/effect-postgres'; import { EffectCache } from 'drizzle-orm/cache/core/cache-effect'; import * as Effect from 'effect/Effect'; import { MyCustomCache } from './cache'; const program = Effect.gen(function*() { const db = yield* PgDrizzle.make({ /* schema, relations, casing */ }).pipe( Effect.provide(EffectCache.layerFromDrizzle(new MyCustomCache())), Effect.provide(PgDrizzle.DefaultServices), ); const users = yield* db.select().from(usersTable); return users; }); ```

Effect Postgres dependency injection example

Example of creating a reusable DB layer for dependency injection with Effect Postgres: ```typescript import * as PgDrizzle from 'drizzle-orm/effect-postgres'; import { PgClient } from '@effect/sql-pg'; import * as Context from 'effect/Context'; import * as Effect from 'effect/Effect'; import * as Layer from 'effect/Layer'; import * as Redacted from 'effect/Redacted'; import { types } from 'pg'; import * as relations from './schema/relations'; const PgClientLive = PgClient.layer({ url: Redacted.make(process.env.DATABASE_URL!), types: { getTypeParser: (typeId, format) => { if ([1184, 1114, 1082, 1186, 1231, 1115, 1185, 1187, 1182].includes(typeId)) { return (val: any) => val; } return types.getTypeParser(typeId, format); }, }, }); const dbEffect = PgDrizzle.make({ relations }).pipe( Effect.provide(PgDrizzle.DefaultServices) ); class DB extends Context.Tag('DB')<DB, Effect.Effect.Success<typeof dbEffect>>() {} const DBLive = Layer.effect( DB, Effect.gen(function*() { return yield* dbEffect; }), ); const AppLive = Layer.provideMerge(DBLive, PgClientLive); const program = Effect.gen(function*() { const db = yield* DB; const users = yield* db.select().from(usersTable); return users; }); Effect.runPromise(program.pipe(Effect.provide(AppLive))); ```

PgDrizzle.DefaultServices provides default logger and cache

PgDrizzle.DefaultServices is an Effect Layer that provides default implementations for logger and cache services. It is used when calling PgDrizzle.make() to fill in services not explicitly provided by the user.

effect-schema: create insert, update, and select schemas from tables

The effect-schema package allows you to generate Effect schemas from Drizzle ORM table definitions. Three main functions are available: createInsertSchema generates a schema for inserting records into tables, createUpdateSchema generates a schema for updating records, and createSelectSchema generates a schema for selecting records from tables. These schemas can be used to validate API requests and responses.

createInsertSchema imports and basic usage

Import createInsertSchema, createUpdateSchema, and createSelectSchema from 'drizzle-orm/effect-schema'. Call createInsertSchema(tableDefinition) to generate a schema for insert operations. Call createUpdateSchema(tableDefinition) to generate a schema for update operations. Call createSelectSchema(tableDefinition) to generate a schema for select operations.

effect-schema override fields with custom schemas

When calling createInsertSchema, createUpdateSchema, or createSelectSchema, pass a second parameter object to override field definitions. The object keys are field names and values are custom Effect Schema definitions. For example: createInsertSchema(users, { role: Schema.String }) overrides the role field with a custom Schema.String definition.

effect-schema refine fields before nullable/optional transformation

When creating schemas, you can pass a second parameter with field refinements using a function pattern. The function receives the generated schema and returns a refined version. For example: createInsertSchema(users, { id: (schema) => schema.check(Schema.isGreaterThanOrEqualTo(0)) }) applies a check to the id field before it becomes nullable or optional in the final schema.

effect-schema example: createInsertSchema with table and validation

Example showing createInsertSchema usage with a pgTable definition and Effect runtime validation: ```ts import { pgTable, serial, text, timestamp } from 'drizzle-orm/pg-core'; import { createInsertSchema } from 'drizzle-orm/effect-schema'; import { Effect, Schema } from "effect"; const users = pgTable('users', { id: serial().primaryKey(), name: text().notNull(), email: text().notNull(), role: text({ enum: ['admin', 'user'] }).notNull(), createdAt: timestamp('created_at').notNull().defaultNow(), }); const UserInsert = createInsertSchema(users); const program = Effect.gen(function*() { const parsedUser = yield* Schema.decodeUnknownEffect(UserInsert)({ name: 'John Doe', email: 'johndoe@test.com', role: 'admin', }); }); ```

Effect integration in v1.0

Drizzle ORM v1.0 adds Effect integration including support for the `@effect/sql-pg` driver and Effect Schema validation via the `drizzle-orm/effect-schema` package.

Give your agent this brain