rivet-gg / opengb Goto Github PK

We serve multiple Prisma instances, but they share the same library and WASM. Explore making them all import the same runtime to safe both (a) binary size and (b) memory usage.

This will require some finessing of the imports.

This may become essential if we get close to going over the 10 MB limit for Cloudflare Workers.

Maybe we can use a shared runtime/library.js to save space?

Our fork of the esbuild-plugin-polyfill-node package is not available on NPM, so we have to run it as an NPM package.

Deno does not support Git NPM specifiers yet: denoland/deno#15960

Workaround #1: use esbuild-plugin-polyfill-node to package itself for use in Deno.

Workaround #2: Use https://esm.sh/ to build & serve the module. Could not figure this out the first go, though.

As of #63 CORS defaults to *

If a module calls other modules, list which dependencies it calls in the module.yaml.

Developers will only be able to call the explicit dependencies from ModuleContext (and its subclasses).

This is intended to just be a name, not a reference to a specific registry + module like NPM.

Eventually: dependencies will be able to be remapped (i.e. if I have a fork of the "users" module).

• Locking rows (inventory example)
• Unlogged tables for real time data
• Access logs & point in time recovery
• Other extensions?

• Use UUIDs for indexes (and why)
• Use camel case for keys
• Never delete values
• Manually altering migrations as needed to add constraints
• Recommended types (dates, uuid, integer, floats, etc)

This PR includes dependencies on @ogs/helpers/registry.d.ts in the engine itself. This file is generated and cannot be referenced from within the engine. The Registry generic must be passed to the types that use it directly instead of importing it from within the engine.

#51

Don't tackle Drizzle just yet, keep Deno Postgres ORM

Leave types as JSON schema + Ajv validation

Needs deno.json & .gitignore

We currently export prisma (which holds the types) and Prisma (which holds the utility functions).

To reference a type, you need to use primsa.Prisma.XXXXGetPayload while to use a utility function, you need to use Prisma.xxxx.

Ideally it's just Prisma for both types and utils

Required for hosting API endpoints.

The default module calling API is meant to be an easy way to call modules that covers use cases where you control the code that calls the server, not as a complete HTTP req/res interface.

• Get JSON Schema from config.ts
• Validate config
• Pass to module context
• Pass to runtime entrypoint

Run a test with deno test --trace-ops and disable sanitizeOps in Runtime.test to see the issue:

    at op_sleep (ext:core/00_infra.js:265:13)
    at runAfterTimeout (ext:deno_web/02_timers.js:234:20)
    at initializeTimer (ext:deno_web/02_timers.js:192:3)
    at setTimeout (ext:deno_web/02_timers.js:336:10)
    at pm (file:///Users/nathan/rivet/ogs/dist/prisma/friends/esm.js:7264:14)
    at <anonymous> (wasm://wasm/00952342:1:2131297)
    at <anonymous> (wasm://wasm/00952342:1:2153871)
    at am (file:///Users/nathan/rivet/ogs/dist/prisma/friends/esm.js:7183:9)
    at n (file:///Users/nathan/rivet/ogs/dist/prisma/friends/esm.js:7252:20)
    at new Promise (<anonymous>)

Sanitize ops is disabled until this can be fixed.

Example: ctx.users.get({ … })

This should only make the listed dependencies available in the given context. If using a context that's not ModuleContext, then all modules are available. Should be easy to do using a Partial.

Any module names that conflict with the core types (e.g. db) will be renamed with an underscore. e.g. calling the db module looks like ctx._db.doSomething({})

This needs to have a type-safe req/res format. This will require generating types in the runtime_config.ts file.

This will include:

• (Later) all errors for the module
• (Later) the Drizzle schema
• (Later) schema for all other modules in the project

prisma/prisma#4246

Encourage using $queryRaw if needed

Make only dependencies available if they're listed in the module's yaml

ctx.modules.<module_name>.<script_name>({}) should be type safe, awaitable, and not be overloaded by typescript resolve times

Automatically update the deno.json to specify the OGS runtime path

Need to figure out how (and if) this works with OpenAPI

Need to figure out the easiest x-platform solution

Can we support multiple protocols?

Prior art:

• Rivet uses blocking requests for server side events
• SSE work, but have limitations on number of concurrent streams
• WS works, but requires extra libraries that are usually finicky on non-web platforms
• gRPC requires protobuf and has a weird handler requirement for WebSockets. Raw TCP will not play nice on edge functions & most load balancers.
• tRPC is a joke

When running a Prisma command from Deno, it fails to exit cleanly with this warning:

Warning: Not implemented: ChildProcess.prototype.disconnect

The user has to manually press enter for this to continue.

One workaround is to go back to using npx instead of deno, but this requires developers to install Node in addition to Deno.

Make sure the database backend is pluggable between:

• Neon serverless
• postgres.js

This will read the types from the parameters on the run config on the fly

Make sure to validate UUIDs

removes ajv

https://www.prisma.io/docs/orm/overview/databases/neon#how-to-use-neons-serverless-driver-with-prisma-preview