mirror of
https://github.com/Effect-TS/effect.git
synced 2026-11-22 05:03:05 +08:00
212 lines
9.1 KiB
TypeScript
212 lines
9.1 KiB
TypeScript
import { SqliteClient } from "@effect/sql-sqlite-node"
|
|
import { assert, describe, it } from "@effect/vitest"
|
|
import { Effect, Layer, Redacted } from "effect"
|
|
import * as RegressionTest from "effect-test/eventlog/EventLogServerUnencryptedRegressionTest"
|
|
import * as SqlEventLogServerUnencryptedStorageTest from "effect-test/eventlog/SqlEventLogServerUnencryptedStorageTest"
|
|
import * as EventJournal from "effect/eventlog/EventJournal"
|
|
import * as EventLog from "effect/eventlog/EventLog"
|
|
import * as EventLogEncryption from "effect/eventlog/EventLogEncryption"
|
|
import * as EventLogMessage from "effect/eventlog/EventLogMessage"
|
|
import * as EventLogServerUnencrypted from "effect/eventlog/EventLogServerUnencrypted"
|
|
import * as EventLogSessionAuth from "effect/eventlog/EventLogSessionAuth"
|
|
import { makeGetIdentityRootSecretMaterial } from "effect/eventlog/internal/identityRootSecretDerivation"
|
|
import * as SqlEventLogServerUnencrypted from "effect/eventlog/SqlEventLogServerUnencrypted"
|
|
import { Reactivity } from "effect/reactivity"
|
|
import * as RpcTest from "effect/rpc/RpcTest"
|
|
import * as SqlClient from "effect/sql/SqlClient"
|
|
import * as Statement from "effect/sql/Statement"
|
|
|
|
SqlEventLogServerUnencryptedStorageTest.suite(
|
|
"sql-sqlite-node",
|
|
SqliteClient.layer({
|
|
filename: ":memory:"
|
|
})
|
|
)
|
|
|
|
RegressionTest.suite(
|
|
"SQLite",
|
|
SqlEventLogServerUnencrypted.layerStorage().pipe(
|
|
Layer.provide(SqliteClient.layer({ filename: ":memory:" })),
|
|
Layer.provide(Reactivity.layer)
|
|
)
|
|
)
|
|
|
|
const getIdentityRootSecretMaterial = makeGetIdentityRootSecretMaterial(globalThis.crypto)
|
|
const storeId = EventLogMessage.StoreId.make("store-a")
|
|
|
|
const makeEntry = (value: number) =>
|
|
new EventJournal.Entry({
|
|
id: EventJournal.makeEntryIdUnsafe(),
|
|
event: "UserCreated",
|
|
primaryKey: `user-${value}`,
|
|
payload: new Uint8Array([value])
|
|
}, { disableChecks: true })
|
|
|
|
const makeAuthenticateRequest = Effect.fnUntraced(function*(options: {
|
|
readonly identity: EventLog.Identity["Service"]
|
|
readonly challenge: Uint8Array
|
|
readonly remoteId: EventJournal.RemoteId
|
|
}) {
|
|
const rootSecretMaterial = yield* getIdentityRootSecretMaterial(options.identity)
|
|
const signature = yield* EventLogSessionAuth.signSessionAuthPayload({
|
|
remoteId: options.remoteId,
|
|
challenge: options.challenge,
|
|
publicKey: options.identity.publicKey,
|
|
signingPublicKey: rootSecretMaterial.signingPublicKey,
|
|
signingPrivateKey: Redacted.value(rootSecretMaterial.signingPrivateKey)
|
|
})
|
|
return new EventLogMessage.Authenticate({
|
|
publicKey: options.identity.publicKey,
|
|
signingPublicKey: rootSecretMaterial.signingPublicKey,
|
|
signature,
|
|
algorithm: "Ed25519"
|
|
})
|
|
})
|
|
|
|
describe("SqlEventLogServerUnencrypted (sql-sqlite-node)", () => {
|
|
it.effect("forbids writing entries for another identity", () =>
|
|
Effect.gen(function*() {
|
|
const sql = yield* SqliteClient.make({ filename: ":memory:" })
|
|
const storage = yield* SqlEventLogServerUnencrypted.makeStorage().pipe(
|
|
Effect.provideService(SqlClient.SqlClient, sql),
|
|
Effect.orDie
|
|
)
|
|
const rpcClient = yield* RpcTest.makeClient(EventLogMessage.EventLogRemoteRpcs).pipe(
|
|
Effect.provide(
|
|
EventLogServerUnencrypted.layerRpcHandlers.pipe(
|
|
Layer.provideMerge(EventLog.layerRegistry),
|
|
Layer.provide(Layer.succeed(EventLogServerUnencrypted.Storage, storage)),
|
|
Layer.provide(Layer.succeed(EventLogServerUnencrypted.StoreMapping, {
|
|
resolve: ({ storeId }) => Effect.succeed(storeId),
|
|
hasStore: () => Effect.succeed(true)
|
|
})),
|
|
Layer.provide(Layer.succeed(EventLogServerUnencrypted.EventLogServerAuthorization, {
|
|
authorizeWrite: () => Effect.void,
|
|
authorizeRead: () => Effect.void,
|
|
authorizeIdentity: () => Effect.void
|
|
}))
|
|
)
|
|
)
|
|
)
|
|
const identityA = yield* EventLog.makeIdentity
|
|
const identityB = yield* EventLog.makeIdentity
|
|
const hello = yield* rpcClient["EventLog.Hello"]()
|
|
yield* rpcClient["EventLog.Authenticate"](
|
|
yield* makeAuthenticateRequest({
|
|
identity: identityA,
|
|
challenge: hello.challenge,
|
|
remoteId: hello.remoteId
|
|
})
|
|
)
|
|
const data = yield* new EventLogMessage.WriteEntriesUnencrypted({
|
|
publicKey: identityB.publicKey,
|
|
storeId,
|
|
entries: [makeEntry(1)]
|
|
}).encoded
|
|
|
|
const error = yield* rpcClient["EventLog.WriteSingle"]({ data }).pipe(Effect.flip)
|
|
|
|
assert.instanceOf(error, EventLogMessage.EventLogProtocolError)
|
|
assert.strictEqual(error.code, "Forbidden")
|
|
const written = yield* storage.write(storeId, [makeEntry(2)])
|
|
assert.deepStrictEqual(written.map((entry) => entry.remoteSequence), [1])
|
|
}).pipe(Effect.provide([Reactivity.layer, EventLogEncryption.layerSubtle])))
|
|
|
|
it.effect("rejects session-auth rebinding for an existing publicKey", () =>
|
|
Effect.gen(function*() {
|
|
const sql = yield* SqliteClient.make({ filename: ":memory:" })
|
|
const storage = yield* SqlEventLogServerUnencrypted.makeStorage().pipe(
|
|
Effect.provideService(SqlClient.SqlClient, sql),
|
|
Effect.orDie
|
|
)
|
|
|
|
const rpcClient = yield* RpcTest.makeClient(EventLogMessage.EventLogRemoteRpcs).pipe(
|
|
Effect.provide(
|
|
EventLogServerUnencrypted.layerRpcHandlers.pipe(
|
|
Layer.provideMerge(EventLog.layerRegistry),
|
|
Layer.provide(Layer.succeed(EventLogServerUnencrypted.Storage, storage)),
|
|
Layer.provide(Layer.succeed(EventLogServerUnencrypted.StoreMapping, {
|
|
resolve: ({ storeId }) => Effect.succeed(storeId),
|
|
hasStore: () => Effect.succeed(true)
|
|
})),
|
|
Layer.provide(Layer.succeed(EventLogServerUnencrypted.EventLogServerAuthorization, {
|
|
authorizeWrite: () => Effect.void,
|
|
authorizeRead: () => Effect.void,
|
|
authorizeIdentity: () => Effect.void
|
|
}))
|
|
)
|
|
)
|
|
)
|
|
|
|
const firstIdentity = yield* EventLog.makeIdentity
|
|
const secondIdentitySeed = yield* EventLog.makeIdentity
|
|
const secondIdentity: EventLog.Identity["Service"] = {
|
|
publicKey: firstIdentity.publicKey,
|
|
privateKey: secondIdentitySeed.privateKey
|
|
}
|
|
|
|
const firstMaterial = yield* getIdentityRootSecretMaterial(firstIdentity)
|
|
const secondMaterial = yield* getIdentityRootSecretMaterial(secondIdentity)
|
|
const sameSigningPublicKey =
|
|
firstMaterial.signingPublicKey.byteLength === secondMaterial.signingPublicKey.byteLength &&
|
|
firstMaterial.signingPublicKey.every((byte, index) => byte === secondMaterial.signingPublicKey[index])
|
|
assert.strictEqual(sameSigningPublicKey, false)
|
|
|
|
const firstHello = yield* rpcClient["EventLog.Hello"]()
|
|
yield* rpcClient["EventLog.Authenticate"](
|
|
yield* makeAuthenticateRequest({
|
|
identity: firstIdentity,
|
|
challenge: firstHello.challenge,
|
|
remoteId: firstHello.remoteId
|
|
})
|
|
)
|
|
|
|
const secondHello = yield* rpcClient["EventLog.Hello"]()
|
|
const error = yield* rpcClient["EventLog.Authenticate"](
|
|
yield* makeAuthenticateRequest({
|
|
identity: secondIdentity,
|
|
challenge: secondHello.challenge,
|
|
remoteId: secondHello.remoteId
|
|
})
|
|
).pipe(Effect.flip)
|
|
|
|
assert.instanceOf(error, EventLogMessage.EventLogProtocolError)
|
|
assert.strictEqual(error.code, "Forbidden")
|
|
assert.strictEqual(error.message, "Session auth signature verification failed")
|
|
}).pipe(Effect.provide([Reactivity.layer, EventLogEncryption.layerSubtle])))
|
|
|
|
it.effect("reads batch history through id and primary key lookups", () => {
|
|
const statements: Array<readonly [string, ReadonlyArray<unknown>]> = []
|
|
return Effect.gen(function*() {
|
|
const sql = yield* SqlClient.SqlClient
|
|
const { write } = yield* RegressionTest.makeClient("plan")
|
|
yield* write([yield* RegressionTest.makeEntry(2_000, "a"), yield* RegressionTest.makeEntry(3_000, "b")])
|
|
statements.length = 0
|
|
yield* write([yield* RegressionTest.makeEntry(1_000, "a")])
|
|
|
|
const reads = statements.filter(([text]) => /^\s*SELECT\b/i.test(text) && text.includes(`"effect_events"`))
|
|
assert.isNotEmpty(reads)
|
|
for (const [text, params] of reads) {
|
|
const plan = yield* sql.unsafe<{ readonly detail: string }>(`EXPLAIN QUERY PLAN ${text}`, params)
|
|
for (const { detail } of plan.filter(({ detail }) => detail.includes("effect_events"))) {
|
|
// A range on entry_id alone reads every entry after the batch.
|
|
assert.match(detail, /^SEARCH effect_events USING (COVERING )?INDEX \S+ \(.*\b(entry_id|primary_key)=\?/)
|
|
}
|
|
}
|
|
}).pipe(
|
|
Effect.provide(
|
|
SqlEventLogServerUnencrypted.layerStorage().pipe(
|
|
Layer.provideMerge(SqliteClient.layer({ filename: ":memory:" })),
|
|
Layer.provide(Reactivity.layer)
|
|
)
|
|
),
|
|
Effect.provide(EventLogEncryption.layerSubtle),
|
|
Effect.provideService(Statement.CurrentTransformer, (statement) =>
|
|
Effect.sync(() => {
|
|
statements.push(statement.compile())
|
|
return statement
|
|
}))
|
|
)
|
|
})
|
|
})
|