A Fetch API-compatible PlanetScale database driver. 

A Fetch API-compatible PlanetScale database driver

dgraham

ayrton

iheanyi

planetscale-npm

iamjasonlong

planetfrances

@planetscale/database

skullface

pixeljanitor

import { format } from './sanitization.js';

export { format } from './sanitization.js';

export class DatabaseError extends Error {

        return this.connection().transaction(fn);

    async execute(query, args = null, options = defaultExecuteOptions) {

        return this.connection().execute(query, args, options);

        return new Connection(this.config);

        return this.conn.execute(query, args, options);

        if (typeof fetch !== 'undefined') {

            (_a = this.config).fetch || (_a.fetch = fetch);

            const url = new URL(config.url);

            this.config.username = url.username;

            this.config.password = url.password;

            this.config.host = url.hostname;

        const conn = new Connection(this.config);

            await tx.execute('ROLLBACK');

        const url = new URL('/psdb.v1alpha1.Database/Execute', `https://${this.config.host}`);

        const formatter = this.config.format || format;

        const sql = args ? formatter(query, args) : query;

        const saved = await postJSON(this.config, url, { query: sql, session: this.session });

        const { result, session, error, timing } = saved;

            throw new DatabaseError(error.message, 400, error);

        const rowsAffected = result?.rowsAffected ? parseInt(result.rowsAffected, 10) : 0;

        const insertId = result?.insertId ?? '0';

        const fields = result?.fields ?? [];

            field.type || (field.type = 'NULL');

        const castFn = options.cast || this.config.cast || cast;

        const rows = result ? parse(result, castFn, options.as || 'object') : [];

        const headers = fields.map((f) => f.name);

        const typeByName = (acc, { name, type }) => ({ ...acc, [name]: type });

        const types = fields.reduce(typeByName, {});

        const timingSeconds = timing ?? 0;

            return JSON.parse(decode(value));

  "description": "A Fetch API-compatible PlanetScale database driver",

    "version": "echo \"export const Version = '$npm_package_version'\" > src/version.ts && git add src/version.ts && npm run build",

    "postpublish": "npm publish --ignore-scripts --@planetscale:registry='https://npm.pkg.github.com'"

    "url": "git+https://github.com/planetscale/database-js.git"

    "url": "https://github.com/planetscale/database-js/issues"

  "homepage": "https://github.com/planetscale/database-js#readme",

    "@typescript-eslint/eslint-plugin": "^5.31.0",

    "@typescript-eslint/parser": "^5.31.0",

      "plugin:@typescript-eslint/recommended",

    "parser": "@typescript-eslint/parser",

      "@typescript-eslint/no-explicit-any": "off",

      "@typescript-eslint/no-empty-function": "off",

      "@typescript-eslint/ban-ts-comment": "off"

# PlanetScale Serverless Driver for JavaScript

A Fetch API-compatible PlanetScale database driver for serverless and edge compute platforms that require HTTP external connections, such as Cloudflare Workers or Vercel Edge Functions

import { connect } from '@planetscale/database'

const results = await conn.execute('select 1 from dual where 1=?', [1])

A single database URL value can be used to configure the `host`, `username`, and `password` values.

  url: process.env['DATABASE_URL'] || 'mysql://user:pass@host'

Use the `Client` connection factory class to create fresh connections for each transaction or web request handler.

import { Client } from '@planetscale/database'

const results = await conn.execute('select 1 from dual')

Use the `transaction` function to safely perform database transactions. If any unhandled errors are thrown during execution of the transaction, the transaction will be rolled back.

The following example is based on [the Slotted Counter Pattern](https://planetscale.com/blog/the-slotted-counter-pattern).

const results = await conn.transaction(async (tx) => {

  const whenBranch = await tx.execute('INSERT INTO branches (database_id, name) VALUES (?, ?)', [42, "planetscale"])

  const whenCounter = await tx.execute('INSERT INTO slotted_counters(record_type, record_id, slot, count) VALUES (?, ?, RAND() * 100, 1) ON DUPLICATE KEY UPDATE count = count + 1', ['branch_count', 42])

Node.js version 18 includes a built-in global `fetch` function. When using an older version of Node.js, you can provide a custom fetch function implementation. We recommend the [`undici`][1] package on which Node's built-in fetch is based.

To leverage HTTP/2, you can use the [`fetch-h2`][1] shim. `fetch-h2` also supports Node.js 12+.

To leverage HTTP/2, you can use the [`fetch-h2`][2] shim. `fetch-h2` also supports Node.js 12+.

[1]: https://www.npmjs.com/package/fetch-h2

[2]: https://www.npmjs.com/package/fetch-h2

const { fetch, disconnectAll } = context()

### Custom query parameter format function

Query replacement parameters identified with `?` are replaced with escaped values. Named replacement parameters are supported with a colon prefix.

const results1 = await conn.execute('select 1 from dual where 1=?', [42])

const results2 = await conn.execute('select 1 from dual where 1=:id', { id: 42 })

Providing a custom format function overrides the built-in escaping with an external library, like [`sqlstring`](https://github.com/mysqljs/sqlstring).

const results = await conn.execute('select 1 from dual where 1=?', [42])

Column values are converted to their corresponding JavaScript data types. This can be customized by providing a `cast` function.

import { connect, cast } from '@planetscale/database'

  if (field.type === 'INT64' || field.type === 'UINT64') {

You can also pass a custom `cast` function to `execute`. If present, this will override the `cast` function set by the connection:

  'SELECT userId, SUM(balance) AS balance FROM UserBalanceItem GROUP BY userId',

Rows can be returned as an object or an array of column values by passing an `as` option to `execute`.

const query = 'select 1 as one, 2 as two where 1=?'

const objects = conn.execute(query, [1], { as: 'object' })

// objects.rows => [{one: '1', two: '2'}]

const arrays = conn.execute(query, [1], { as: 'array' })

		@@ -205,2 +205,3 @@ import { format } from './sanitization.js';
		case 'BINARY':
		case 'GEOMETRY':
		return value;
		@@ -207,0 +208,0 @@ case 'JSON':

		{
		"name": "@planetscale/database",
		"version": "1.7.0",
		"version": "1.8.0",
		"description": "A Fetch API-compatible PlanetScale database driver",
		@@ -5,0 +5,0 @@ "main": "dist/index.js",

		@@ -1,1 +0,1 @@
		export declare const Version = "1.7.0";
		export declare const Version = "1.8.0";

		@@ -1,1 +0,1 @@
		export const Version = '1.7.0';
		export const Version = '1.8.0';

		@@ -105,5 +105,5 @@ # PlanetScale Serverless Driver for JavaScript

		To leverage HTTP/2, you can use the [`fetch-h2`][1] shim. `fetch-h2` also supports Node.js 12+.
		To leverage HTTP/2, you can use the [`fetch-h2`][2] shim. `fetch-h2` also supports Node.js 12+.

		[1]: https://www.npmjs.com/package/fetch-h2
		[2]: https://www.npmjs.com/package/fetch-h2

		@@ -110,0 +110,0 @@ ```ts

Improved metrics