@di-framework/pglite-component 0.0.0-stage → 6.0.11

package/dist/js/index.js

@@ -0,0 +1,5 @@
+/**
+ * `SqlDatabase` adapter for the `di-framework:pglite/database` WIT interface
+ * this package's component exports. Depends on `@di-framework/repo` as a peer.
+ */
+export * from './adapter.js';

package/package.json

@@ -1,6 +1,67 @@
 {
   "name": "@di-framework/pglite-component",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "6.0.11",
+  "type": "module",
+  "description": "Embedded PostgreSQL component with persistent WASI storage and no TCP, plus its SqlDatabase adapter for @di-framework/repo.",
+  "license": "(MIT OR Apache-2.0)",
+  "author": "@di-framework Contributors",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/di-framework/platform",
+    "directory": "platform/pglite-component"
+  },
+  "bugs": {
+    "url": "https://github.com/di-framework/platform/issues"
+  },
+  "homepage": "https://github.com/di-framework/platform",
+  "keywords": [
+    "postgresql",
+    "pglite",
+    "wasi",
+    "wit",
+    "webassembly",
+    "component-model",
+    "di-framework"
+  ],
+  "main": "./dist/js/index.js",
+  "types": "./dist/js/index.d.ts",
+  "module": "./dist/js/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/js/index.d.ts",
+      "bun": "./dist/js/index.js",
+      "import": "./dist/js/index.js",
+      "default": "./dist/js/index.js"
+    },
+    "./wasm": "./dist/di-framework-pglite.wasm",
+    "./wit": "./dist/di-framework-pglite.wit",
+    "./wit/*": "./wit/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/js",
+    "dist/di-framework-pglite.wasm",
+    "dist/di-framework-pglite.wit",
+    "dist/BUILD-INFO.txt",
+    "dist/SHA256SUMS",
+    "dist/THIRD-PARTY-NOTICES.txt",
+    "README.md",
+    "wit",
+    "LICENSE-MIT",
+    "LICENSE-APACHE"
+  ],
+  "scripts": {
+    "build": "bun run build:adapter && make build",
+    "build:adapter": "bun scripts/wit-types.ts --check && rm -rf dist/js && bun x tsc -p tsconfig.build.json && bun ../../scripts/fix-esm-imports.ts dist/js",
+    "wit-types": "bun scripts/wit-types.ts",
+    "test": "bun test",
+    "smoke": "make smoke",
+    "publish-asset": "make publish-asset"
+  },
+  "peerDependencies": {
+    "@di-framework/repo": "^6.1.0"
+  },
+  "devDependencies": {
+    "@di-framework/repo": "^6.1.0"
+  }
+}

package/wit/deps/pglite-engine/engine.wit

@@ -0,0 +1,16 @@
+package di-framework:pglite-engine@0.1.0;
+
+/// Private in-memory bridge to the bundled PostgreSQL engine. Composed away
+/// at build time; these functions are never host imports in the final artifact.
+interface engine {
+  set-env: func(name: string, value: string) -> s32;
+  start: func(arguments: list<string>) -> s32;
+  initdb: func() -> s32;
+  backend: func();
+  write: func(payload: list<u8>) -> bool;
+  read: func() -> list<u8>;
+  step: func();
+}
+world embedded-engine {
+  export engine;
+}

package/wit/deps/wasi-cli-0.2.0/package.wit

@@ -0,0 +1,159 @@
+package wasi:cli@0.2.0;
+
+interface environment {
+  /// Get the POSIX-style environment variables.
+  ///
+  /// Each environment variable is provided as a pair of string variable names
+  /// and string value.
+  ///
+  /// Morally, these are a value import, but until value imports are available
+  /// in the component model, this import function should return the same
+  /// values each time it is called.
+  get-environment: func() -> list<tuple<string, string>>;
+
+  /// Get the POSIX-style arguments to the program.
+  get-arguments: func() -> list<string>;
+
+  /// Return a path that programs should use as their initial current working
+  /// directory, interpreting `.` as shorthand for this.
+  initial-cwd: func() -> option<string>;
+}
+
+interface exit {
+  /// Exit the current instance and any linked instances.
+  exit: func(status: result);
+}
+
+interface run {
+  /// Run the program.
+  run: func() -> result;
+}
+
+interface stdin {
+  use wasi:io/streams@0.2.0.{input-stream};
+
+  get-stdin: func() -> input-stream;
+}
+
+interface stdout {
+  use wasi:io/streams@0.2.0.{output-stream};
+
+  get-stdout: func() -> output-stream;
+}
+
+interface stderr {
+  use wasi:io/streams@0.2.0.{output-stream};
+
+  get-stderr: func() -> output-stream;
+}
+
+/// Terminal input.
+///
+/// In the future, this may include functions for disabling echoing,
+/// disabling input buffering so that keyboard events are sent through
+/// immediately, querying supported features, and so on.
+interface terminal-input {
+  /// The input side of a terminal.
+  resource terminal-input;
+}
+
+/// Terminal output.
+///
+/// In the future, this may include functions for querying the terminal
+/// size, being notified of terminal size changes, querying supported
+/// features, and so on.
+interface terminal-output {
+  /// The output side of a terminal.
+  resource terminal-output;
+}
+
+/// An interface providing an optional `terminal-input` for stdin as a
+/// link-time authority.
+interface terminal-stdin {
+  use terminal-input.{terminal-input};
+
+  /// If stdin is connected to a terminal, return a `terminal-input` handle
+  /// allowing further interaction with it.
+  get-terminal-stdin: func() -> option<terminal-input>;
+}
+
+/// An interface providing an optional `terminal-output` for stdout as a
+/// link-time authority.
+interface terminal-stdout {
+  use terminal-output.{terminal-output};
+
+  /// If stdout is connected to a terminal, return a `terminal-output` handle
+  /// allowing further interaction with it.
+  get-terminal-stdout: func() -> option<terminal-output>;
+}
+
+/// An interface providing an optional `terminal-output` for stderr as a
+/// link-time authority.
+interface terminal-stderr {
+  use terminal-output.{terminal-output};
+
+  /// If stderr is connected to a terminal, return a `terminal-output` handle
+  /// allowing further interaction with it.
+  get-terminal-stderr: func() -> option<terminal-output>;
+}
+
+world imports {
+  import environment;
+  import exit;
+  import wasi:io/error@0.2.0;
+  import wasi:io/poll@0.2.0;
+  import wasi:io/streams@0.2.0;
+  import stdin;
+  import stdout;
+  import stderr;
+  import terminal-input;
+  import terminal-output;
+  import terminal-stdin;
+  import terminal-stdout;
+  import terminal-stderr;
+  import wasi:clocks/monotonic-clock@0.2.0;
+  import wasi:clocks/wall-clock@0.2.0;
+  import wasi:filesystem/types@0.2.0;
+  import wasi:filesystem/preopens@0.2.0;
+  import wasi:sockets/network@0.2.0;
+  import wasi:sockets/instance-network@0.2.0;
+  import wasi:sockets/udp@0.2.0;
+  import wasi:sockets/udp-create-socket@0.2.0;
+  import wasi:sockets/tcp@0.2.0;
+  import wasi:sockets/tcp-create-socket@0.2.0;
+  import wasi:sockets/ip-name-lookup@0.2.0;
+  import wasi:random/random@0.2.0;
+  import wasi:random/insecure@0.2.0;
+  import wasi:random/insecure-seed@0.2.0;
+}
+world command {
+  import environment;
+  import exit;
+  import wasi:io/error@0.2.0;
+  import wasi:io/poll@0.2.0;
+  import wasi:io/streams@0.2.0;
+  import stdin;
+  import stdout;
+  import stderr;
+  import terminal-input;
+  import terminal-output;
+  import terminal-stdin;
+  import terminal-stdout;
+  import terminal-stderr;
+  import wasi:clocks/monotonic-clock@0.2.0;
+  import wasi:clocks/wall-clock@0.2.0;
+  import wasi:filesystem/types@0.2.0;
+  import wasi:filesystem/preopens@0.2.0;
+  import wasi:sockets/network@0.2.0;
+  import wasi:sockets/instance-network@0.2.0;
+  import wasi:sockets/udp@0.2.0;
+  import wasi:sockets/udp-create-socket@0.2.0;
+  import wasi:sockets/tcp@0.2.0;
+  import wasi:sockets/tcp-create-socket@0.2.0;
+  import wasi:sockets/ip-name-lookup@0.2.0;
+  import wasi:random/random@0.2.0;
+  import wasi:random/insecure@0.2.0;
+  import wasi:random/insecure-seed@0.2.0;
+
+  export run;
+}

package/wit/deps/wasi-clocks-0.2.0/package.wit

@@ -0,0 +1,29 @@
+package wasi:clocks@0.2.0;
+
+interface monotonic-clock {
+  use wasi:io/poll@0.2.0.{pollable};
+
+  type instant = u64;
+
+  type duration = u64;
+
+  now: func() -> instant;
+
+  resolution: func() -> duration;
+
+  subscribe-instant: func(when: instant) -> pollable;
+
+  subscribe-duration: func(when: duration) -> pollable;
+}
+
+interface wall-clock {
+  record datetime {
+    seconds: u64,
+    nanoseconds: u32,
+  }
+
+  now: func() -> datetime;
+
+  resolution: func() -> datetime;
+}
+

package/wit/deps/wasi-filesystem-0.2.0/package.wit

@@ -0,0 +1,158 @@
+package wasi:filesystem@0.2.0;
+
+interface types {
+  use wasi:io/streams@0.2.0.{input-stream, output-stream, error};
+  use wasi:clocks/wall-clock@0.2.0.{datetime};
+
+  type filesize = u64;
+
+  enum descriptor-type {
+    unknown,
+    block-device,
+    character-device,
+    directory,
+    fifo,
+    symbolic-link,
+    regular-file,
+    socket,
+  }
+
+  flags descriptor-flags {
+    read,
+    write,
+    file-integrity-sync,
+    data-integrity-sync,
+    requested-write-sync,
+    mutate-directory,
+  }
+
+  flags path-flags {
+    symlink-follow,
+  }
+
+  flags open-flags {
+    create,
+    directory,
+    exclusive,
+    truncate,
+  }
+
+  type link-count = u64;
+
+  record descriptor-stat {
+    %type: descriptor-type,
+    link-count: link-count,
+    size: filesize,
+    data-access-timestamp: option<datetime>,
+    data-modification-timestamp: option<datetime>,
+    status-change-timestamp: option<datetime>,
+  }
+
+  variant new-timestamp {
+    no-change,
+    now,
+    timestamp(datetime),
+  }
+
+  record directory-entry {
+    %type: descriptor-type,
+    name: string,
+  }
+
+  enum error-code {
+    access,
+    would-block,
+    already,
+    bad-descriptor,
+    busy,
+    deadlock,
+    quota,
+    exist,
+    file-too-large,
+    illegal-byte-sequence,
+    in-progress,
+    interrupted,
+    invalid,
+    io,
+    is-directory,
+    loop,
+    too-many-links,
+    message-size,
+    name-too-long,
+    no-device,
+    no-entry,
+    no-lock,
+    insufficient-memory,
+    insufficient-space,
+    not-directory,
+    not-empty,
+    not-recoverable,
+    unsupported,
+    no-tty,
+    no-such-device,
+    overflow,
+    not-permitted,
+    pipe,
+    read-only,
+    invalid-seek,
+    text-file-busy,
+    cross-device,
+  }
+
+  enum advice {
+    normal,
+    sequential,
+    random,
+    will-need,
+    dont-need,
+    no-reuse,
+  }
+
+  record metadata-hash-value {
+    lower: u64,
+    upper: u64,
+  }
+
+  resource descriptor {
+    read-via-stream: func(offset: filesize) -> result<input-stream, error-code>;
+    write-via-stream: func(offset: filesize) -> result<output-stream, error-code>;
+    append-via-stream: func() -> result<output-stream, error-code>;
+    advise: func(offset: filesize, length: filesize, advice: advice) -> result<_, error-code>;
+    sync-data: func() -> result<_, error-code>;
+    get-flags: func() -> result<descriptor-flags, error-code>;
+    get-type: func() -> result<descriptor-type, error-code>;
+    set-size: func(size: filesize) -> result<_, error-code>;
+    set-times: func(data-access-timestamp: new-timestamp, data-modification-timestamp: new-timestamp) -> result<_, error-code>;
+    read: func(length: filesize, offset: filesize) -> result<tuple<list<u8>, bool>, error-code>;
+    write: func(buffer: list<u8>, offset: filesize) -> result<filesize, error-code>;
+    read-directory: func() -> result<directory-entry-stream, error-code>;
+    sync: func() -> result<_, error-code>;
+    create-directory-at: func(path: string) -> result<_, error-code>;
+    stat: func() -> result<descriptor-stat, error-code>;
+    stat-at: func(path-flags: path-flags, path: string) -> result<descriptor-stat, error-code>;
+    set-times-at: func(path-flags: path-flags, path: string, data-access-timestamp: new-timestamp, data-modification-timestamp: new-timestamp) -> result<_, error-code>;
+    link-at: func(old-path-flags: path-flags, old-path: string, new-descriptor: borrow<descriptor>, new-path: string) -> result<_, error-code>;
+    open-at: func(path-flags: path-flags, path: string, open-flags: open-flags, %flags: descriptor-flags) -> result<descriptor, error-code>;
+    readlink-at: func(path: string) -> result<string, error-code>;
+    remove-directory-at: func(path: string) -> result<_, error-code>;
+    rename-at: func(old-path: string, new-descriptor: borrow<descriptor>, new-path: string) -> result<_, error-code>;
+    symlink-at: func(old-path: string, new-path: string) -> result<_, error-code>;
+    unlink-file-at: func(path: string) -> result<_, error-code>;
+    is-same-object: func(other: borrow<descriptor>) -> bool;
+    metadata-hash: func() -> result<metadata-hash-value, error-code>;
+    metadata-hash-at: func(path-flags: path-flags, path: string) -> result<metadata-hash-value, error-code>;
+  }
+
+  resource directory-entry-stream {
+    read-directory-entry: func() -> result<option<directory-entry>, error-code>;
+  }
+
+  filesystem-error-code: func(err: borrow<error>) -> option<error-code>;
+}
+
+interface preopens {
+  use types.{descriptor};
+
+  get-directories: func() -> list<tuple<descriptor, string>>;
+}
+