@minnowdb/core 0.2.1 → 0.4.0

package/dist/worker-protocol/index.d.ts

@@ -1,5 +1,7 @@
 export declare const protocolVersion: 2;
-export type WorkerOperation = "ping" | "writeBlock" | "readBlock" | "publishManifest" | "benchmark" | "cancelBenchmark" | "memorySample" | "datasetList" | "datasetCreate" | "datasetDelete" | "runQuery" | "suiteReference" | "suiteWrite" | "suiteFeatureMatrix" | "suiteLive";
+/** Outstanding request/response pairs retained by either side of one database RPC connection. */
+export declare const MAX_DATABASE_RPC_IN_FLIGHT = 256;
+export type WorkerOperation = "benchmark" | "cancelBenchmark" | "memorySample" | "datasetList" | "datasetCreate" | "datasetDelete" | "runQuery" | "suiteReference" | "suiteWrite" | "suiteFeatureMatrix" | "suiteLive";
 export interface WorkerRequest<T = unknown> {
     version: typeof protocolVersion;
     requestId: string;
@@ -81,4 +83,3 @@ export declare function rpcEvent(handleId: string, event: string, payload: unkno
 export declare function parseRpcRequest(value: unknown): RpcRequest | null;
 /** Narrows an incoming message to an RPC response; returns null for non-RPC traffic. */
 export declare function parseRpcResponse(value: unknown): RpcResponse | null;
-//# sourceMappingURL=index.d.ts.map

package/dist/worker-protocol/index.js

@@ -1,4 +1,6 @@
 export const protocolVersion = 2;
+/** Outstanding request/response pairs retained by either side of one database RPC connection. */
+export const MAX_DATABASE_RPC_IN_FLIGHT = 256;
 export function parseRequest(value) {
     if (typeof value !== "object" || value === null)
         throw new TypeError("Request must be an object");
@@ -98,10 +100,6 @@ export function parseRpcResponse(value) {
 }
 function isOperation(value) {
     return [
-        "ping",
-        "writeBlock",
-        "readBlock",
-        "publishManifest",
         "benchmark",
         "cancelBenchmark",
         "memorySample",
@@ -115,4 +113,3 @@ function isOperation(value) {
         "suiteLive",
     ].includes(String(value));
 }
-//# sourceMappingURL=index.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@minnowdb/core",
-  "version": "0.2.1",
-  "description": "A columnar SQL engine that runs entirely in the browser: real SQL over immutable snapshots, durable on IndexedDB or OPFS, with no WebAssembly to download.",
+  "version": "0.4.0",
+  "description": "A columnar SQL database for the browser: PostgreSQL-style SQL over durable IndexedDB or OPFS data, with no server or WebAssembly module.",
   "license": "MIT",
   "author": "Eric Wilhite",
   "homepage": "https://minnowdb.com/docs/",
@@ -41,14 +41,58 @@
       "types": "./dist/engine/client.d.ts",
       "default": "./dist/engine/client.js"
     },
+    "./query": {
+      "types": "./dist/engine/query-api.d.ts",
+      "default": "./dist/engine/query-api.js"
+    },
+    "./live": {
+      "types": "./dist/engine/live-api.d.ts",
+      "default": "./dist/engine/live-api.js"
+    },
+    "./schema": {
+      "types": "./dist/engine/schema.d.ts",
+      "default": "./dist/engine/schema.js"
+    },
+    "./schema-wire": {
+      "types": "./dist/engine/schema-wire.d.ts",
+      "default": "./dist/engine/schema-wire.js"
+    },
     "./worker": {
       "types": "./dist/engine/worker.d.ts",
       "default": "./dist/engine/worker.js"
     },
+    "./worker-host": {
+      "types": "./dist/engine/worker-host.d.ts",
+      "default": "./dist/engine/worker-host.js"
+    },
     "./storage": {
       "types": "./dist/storage/index.d.ts",
       "default": "./dist/storage/index.js"
     },
+    "./storage/contracts": {
+      "types": "./dist/storage/types.d.ts",
+      "default": "./dist/storage/types.js"
+    },
+    "./storage/snapshots": {
+      "types": "./dist/storage/snapshot.d.ts",
+      "default": "./dist/storage/snapshot.js"
+    },
+    "./storage/indexeddb": {
+      "types": "./dist/storage/indexeddb.d.ts",
+      "default": "./dist/storage/indexeddb.js"
+    },
+    "./storage/memory": {
+      "types": "./dist/storage/memory.d.ts",
+      "default": "./dist/storage/memory.js"
+    },
+    "./storage/opfs": {
+      "types": "./dist/storage/opfs/index.d.ts",
+      "default": "./dist/storage/opfs/index.js"
+    },
+    "./storage/persistence": {
+      "types": "./dist/storage/persistence.d.ts",
+      "default": "./dist/storage/persistence.js"
+    },
     "./storage/toolkit": {
       "types": "./dist/storage/toolkit/index.d.ts",
       "default": "./dist/storage/toolkit/index.js"
@@ -69,6 +113,7 @@
       "types": "./dist/testing/index.d.ts",
       "default": "./dist/testing/index.js"
     },
+    "./postgres-feature-profile.json": "./postgres-feature-profile.json",
     "./sql-feature-matrix.json": "./sql-feature-matrix.json",
     "./package.json": "./package.json"
   },
@@ -76,7 +121,12 @@
     "dist",
     "!dist/**/*.test.*",
     "!dist/**/*.spec.*",
+    "!dist/**/*.map",
+    "!dist/storage/fixture-shape.*",
+    "!dist/engine/storage-test-helpers.*",
+    "!dist/testing/seeds.*",
     "!dist/*.tsbuildinfo",
-    "sql-feature-matrix.json"
+    "sql-feature-matrix.json",
+    "postgres-feature-profile.json"
   ]
 }

package/postgres-feature-profile.json

@@ -0,0 +1,223 @@
+{
+  "schemaVersion": 1,
+  "name": "PostgreSQL-style SQL",
+  "oracle": {
+    "engine": "PGlite",
+    "version": "0.5.5",
+    "role": "PostgreSQL parser and result oracle used by the differential test suite"
+  },
+  "scope": {
+    "includes": "The single-database SQL syntax accepted by Minnow and its observable results for each checked example.",
+    "excludes": [
+      "server lifecycle and connections",
+      "catalogs and schemas",
+      "roles, ownership, and privileges",
+      "replication and server extensions",
+      "PostgreSQL storage and administration commands"
+    ]
+  },
+  "classifications": {
+    "compatible": "The checked example uses PostgreSQL syntax. Deterministic reads and mutations match PostgreSQL's result and resulting row state; DDL compatibility is PostgreSQL parser acceptance plus Minnow catalog assertions.",
+    "different": "Minnow supports the concept, but a spelling, type rule, or observable result deliberately differs.",
+    "extension": "Minnow accepts syntax PostgreSQL does not; this is a listed value addition, not PostgreSQL compatibility.",
+    "unsupported": "The feature is meaningful for an embedded database but Minnow does not implement it.",
+    "inapplicable": "The feature belongs to a server capability that an embedded, single-database engine does not expose."
+  },
+  "defaults": {
+    "supported": "compatible",
+    "unsupported": "unsupported"
+  },
+  "overrides": [
+    {
+      "id": "expression.arithmetic",
+      "classification": "different",
+      "reason": "Minnow has one JavaScript number type: integer-looking division stays fractional, and division by zero returns NULL instead of raising PostgreSQL's error."
+    },
+    {
+      "id": "expression.round",
+      "classification": "different",
+      "reason": "Minnow accepts ROUND(double precision, digits); PostgreSQL requires numeric for the two-argument form."
+    },
+    {
+      "id": "parameter.positional",
+      "classification": "extension",
+      "reason": "PostgreSQL uses $n parameters. Minnow also accepts ? as adapter-friendly shorthand."
+    },
+    {
+      "id": "mutation.upsert-replace",
+      "classification": "extension",
+      "reason": "DO REPLACE is Minnow shorthand for replacing every non-key value from EXCLUDED."
+    },
+    {
+      "id": "predicate.match",
+      "classification": "extension",
+      "reason": "MATCH is Minnow's index-transparent full-text predicate rather than a PostgreSQL operator."
+    },
+    {
+      "id": "predicate.match-star",
+      "classification": "extension",
+      "reason": "MATCH(*) searches every text column and is a Minnow full-text extension."
+    },
+    {
+      "id": "predicate.match-parameter",
+      "classification": "extension",
+      "reason": "Parameterized MATCH uses Minnow's index-transparent full-text predicate."
+    },
+    {
+      "id": "function.bm25",
+      "classification": "extension",
+      "reason": "BM25 exposes Minnow's full-text score; PostgreSQL uses its own text-search types and ranking functions."
+    },
+    {
+      "id": "mutation.upsert",
+      "classification": "compatible",
+      "reason": "ON CONFLICT ... DO UPDATE follows PostgreSQL syntax."
+    },
+    {
+      "id": "mutation.insert-do-nothing",
+      "classification": "compatible",
+      "reason": "ON CONFLICT ... DO NOTHING follows PostgreSQL syntax."
+    },
+    {
+      "id": "mutation.upsert-partial",
+      "classification": "compatible",
+      "reason": "A partial SET list with EXCLUDED follows PostgreSQL syntax."
+    },
+    {
+      "id": "predicate.ilike",
+      "classification": "compatible",
+      "reason": "ILIKE follows PostgreSQL syntax and case-insensitive matching semantics."
+    },
+    {
+      "id": "expression.modulo",
+      "classification": "different",
+      "reason": "Minnow permits % on its number type; PostgreSQL has no % operator for double precision."
+    },
+    {
+      "id": "expression.cast",
+      "classification": "different",
+      "reason": "Casting an approximate number to INTEGER truncates in Minnow; PostgreSQL rounds."
+    },
+    {
+      "id": "expression.date-trunc",
+      "classification": "compatible",
+      "reason": "DATE_TRUNC follows PostgreSQL syntax; Minnow evaluates datetimes in UTC because it has no session time zone."
+    },
+    {
+      "id": "function.numeric-core",
+      "classification": "different",
+      "reason": "Minnow's one number type accepts combinations that PostgreSQL's distinct integer, numeric, and double-precision overloads do not."
+    },
+    {
+      "id": "function.string-extended",
+      "classification": "different",
+      "reason": "The bundled form includes INSTR; PostgreSQL spells that function strpos with reversed arguments."
+    },
+    {
+      "id": "function.trim-multi-character",
+      "classification": "different",
+      "reason": "Minnow removes the trim string as a repeated unit; PostgreSQL treats its characters as a set."
+    },
+    {
+      "id": "aggregate.any-value",
+      "classification": "compatible",
+      "verification": "acceptance",
+      "reason": "Both engines accept ANY_VALUE, but which group member it returns is intentionally nondeterministic, so the oracle checks acceptance rather than row equality."
+    },
+    {
+      "id": "aggregate.json",
+      "classification": "different",
+      "reason": "Minnow returns JSON text; PostgreSQL returns a native JSON value, and member order is unspecified without aggregate-local ORDER BY."
+    },
+    {
+      "id": "type.exact-numeric",
+      "classification": "different",
+      "reason": "Minnow preserves exact decimals at the JavaScript boundary as strings; PGlite's default decoder returns this NUMERIC value as a number."
+    },
+    {
+      "id": "type.json-jsonb",
+      "classification": "different",
+      "reason": "Minnow returns canonical JSON text at the JavaScript boundary while PostgreSQL clients commonly decode JSONB to a native object."
+    },
+    {
+      "id": "type.interval",
+      "classification": "different",
+      "reason": "Minnow returns a canonical months/days/microseconds string; PostgreSQL clients use their own interval representation and formatting."
+    },
+    {
+      "id": "type.array",
+      "classification": "different",
+      "reason": "Minnow returns arrays as canonical JSON text at the JavaScript boundary while PostgreSQL clients commonly return native arrays."
+    },
+    {
+      "id": "json.query",
+      "classification": "different",
+      "reason": "The JSON value agrees, but Minnow returns compact JSON text while PostgreSQL's text rendering includes spaces."
+    },
+    {
+      "id": "json.object",
+      "classification": "different",
+      "reason": "The JSON value agrees, but Minnow returns compact JSON text while PostgreSQL's text rendering includes spaces."
+    },
+    {
+      "id": "json.array",
+      "classification": "different",
+      "reason": "The JSON value agrees, but Minnow returns compact JSON text while PostgreSQL's text rendering includes spaces."
+    },
+    {
+      "id": "trigger.create-after",
+      "classification": "different",
+      "reason": "Minnow uses an embedded BEGIN ... END trigger body; PostgreSQL triggers call a separately declared function."
+    },
+    {
+      "id": "trigger.create-before",
+      "classification": "different",
+      "reason": "Minnow uses an embedded BEGIN ... END trigger body; PostgreSQL triggers call a separately declared function."
+    },
+    {
+      "id": "trigger.body-update-delete",
+      "classification": "different",
+      "reason": "Minnow uses an embedded BEGIN ... END trigger body; PostgreSQL triggers call a separately declared function."
+    },
+    {
+      "id": "trigger.drop",
+      "classification": "different",
+      "reason": "PostgreSQL requires DROP TRIGGER name ON table; Minnow's trigger names are database-wide."
+    },
+    {
+      "id": "ddl.secondary-index",
+      "classification": "compatible",
+      "reason": "CREATE INDEX follows PostgreSQL syntax."
+    },
+    {
+      "id": "ddl.drop-secondary-index",
+      "classification": "compatible",
+      "reason": "DROP INDEX follows PostgreSQL syntax."
+    },
+    {
+      "id": "ddl.composite-secondary-index",
+      "classification": "compatible",
+      "reason": "Composite CREATE INDEX follows PostgreSQL syntax."
+    },
+    {
+      "id": "ddl.unique-secondary-index",
+      "classification": "compatible",
+      "reason": "CREATE UNIQUE INDEX follows PostgreSQL syntax."
+    },
+    {
+      "id": "mutation.upsert-expression",
+      "classification": "different",
+      "reason": "Minnow resolves an unqualified target column in DO UPDATE; PostgreSQL treats score beside EXCLUDED.score as ambiguous unless the target is qualified."
+    },
+    {
+      "id": "transaction.isolation-level",
+      "classification": "inapplicable",
+      "reason": "Minnow exposes one snapshot transaction model, so there is no session isolation level to configure."
+    },
+    {
+      "id": "privileges.grant",
+      "classification": "inapplicable",
+      "reason": "An embedded database has no server roles, owners, or GRANT boundary."
+    }
+  ]
+}