@slopware/sloppy-darwin-x64 0.1.0-alpha.0

package/stdlib/sloppy/index.js

@@ -0,0 +1,59 @@
+export { Router, Sloppy } from "./app.js";
+export { Auth } from "./auth.js";
+export { Cache, SloppyCacheError } from "./cache.js";
+export { Base64, Base64Url, Binary, Checksums, Compression, Hex, Text } from "./codec.js";
+export { Config } from "./config.js";
+export { ConstantTime, Hash, Hmac, NonCryptoHash, Password, Random, Secret } from "./crypto.js";
+export { data, Migrations, ProviderHealth, sql } from "./data.js";
+export { t, unsafeFfi } from "./ffi.js";
+export { Directory, File, FileHandle, FileWatcher, Path } from "./fs.js";
+export { Health } from "./health.js";
+export { Metrics } from "./metrics.js";
+export { column, orm, relation, table } from "./orm.js";
+export {
+    Http,
+    HttpClientFactory,
+    HttpError,
+    SloppyHttpClientError,
+    TestHttp,
+} from "./http.js";
+export { SloppyWebhookError, TestWebhooks, Webhooks } from "./webhooks.js";
+export {
+    HttpClient,
+    LocalEndpoint,
+    NamedPipe,
+    NetworkAddress,
+    TcpClient,
+    TcpConnection,
+    TcpListener,
+    UnixSocket,
+} from "./net.js";
+export { Environment, OsError, Process, Signals, System } from "./os.js";
+export { ProblemDetails } from "./problem-details.js";
+export { Realtime, SloppyRealtimeError } from "./realtime.js";
+export { RateLimit, SloppyRateLimitError } from "./rate-limit.js";
+export { Redis, SloppyRedisError } from "./redis.js";
+export { RequestId } from "./request-id.js";
+export { RequestLogging } from "./request-logging.js";
+export { Results } from "./results.js";
+export { Schema } from "./schema.js";
+export { schema } from "./schema.js";
+export { FakeClock, TestData, TestHost, TestServices, Testing } from "./testing.js";
+export {
+    CancelledError,
+    CancellationController,
+    Deadline,
+    InvalidDeadlineError,
+    Time,
+    TimeoutError,
+    TimerDisposedError,
+} from "./time.js";
+export {
+    BackgroundService,
+    SloppyWorkerError,
+    WorkQueue,
+    Worker,
+    WorkerCancellationController,
+    WorkerCancellationSignal,
+    WorkerPool,
+} from "./workers.js";

package/stdlib/sloppy/internal/bytes.js

@@ -0,0 +1,31 @@
+export function copyArrayBuffer(value) {
+    if (value instanceof ArrayBuffer) {
+        return value.slice(0);
+    }
+    if (ArrayBuffer.isView(value)) {
+        return value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength);
+    }
+    return undefined;
+}
+
+export function copyUint8Array(value) {
+    if (value instanceof Uint8Array) {
+        return new Uint8Array(value);
+    }
+    const buffer = copyArrayBuffer(value);
+    return buffer === undefined ? undefined : new Uint8Array(buffer);
+}
+
+export function copyBinaryLike(value) {
+    if (value instanceof ArrayBuffer) {
+        return value.slice(0);
+    }
+    const buffer = copyArrayBuffer(value);
+    if (buffer === undefined) {
+        return undefined;
+    }
+    if (value instanceof DataView) {
+        return new DataView(buffer);
+    }
+    return new value.constructor(buffer);
+}

package/stdlib/sloppy/internal/capabilities.js

@@ -0,0 +1,155 @@
+import { isPlainObject } from "./shared.js";
+
+const DATABASE_ACCESS_MODES = Object.freeze(["read", "write", "readwrite"]);
+
+function validateCapabilityToken(token) {
+    if (typeof token !== "string" || token.length === 0) {
+        throw new TypeError("Sloppy capability token must be a non-empty string.");
+    }
+}
+
+function validateDatabaseCapabilityOptions(options) {
+    if (!isPlainObject(options)) {
+        throw new TypeError("Sloppy database capability options must be a plain object.");
+    }
+
+    if (typeof options.provider !== "string" || options.provider.length === 0) {
+        throw new TypeError("Sloppy database capability provider must be a non-empty string.");
+    }
+
+    if (!DATABASE_ACCESS_MODES.includes(options.access)) {
+        throw new TypeError("Sloppy database capability access must be read, write, or readwrite.");
+    }
+}
+
+
+function snapshotCapability(capability) {
+    return Object.freeze({
+        token: capability.token,
+        kind: capability.kind,
+        provider: capability.provider,
+        access: capability.access,
+        module: capability.module,
+        metadata: Object.freeze({ ...capability.metadata }),
+    });
+}
+
+function createCapabilityRegistry(guard) {
+    const capabilities = new Map();
+    let currentModule = null;
+
+    function addCapability(token, capability) {
+        guard.assertMutable();
+        validateCapabilityToken(token);
+
+        if (capabilities.has(token)) {
+            throw new Error(`sloppy: capability token already declared
+
+Token:
+  ${token}
+
+Fix:
+  Declare each capability token once, or choose a more specific token such as 'data.main'.`);
+        }
+
+        capabilities.set(token, {
+            ...capability,
+            token,
+            module: currentModule,
+        });
+
+        return registry;
+    }
+
+    const registry = {
+        addDatabase(token, options) {
+            validateDatabaseCapabilityOptions(options);
+
+            return addCapability(token, {
+                kind: "database",
+                provider: options.provider,
+                access: options.access,
+                metadata: { ...options },
+            });
+        },
+
+        has(token) {
+            validateCapabilityToken(token);
+            return capabilities.has(token);
+        },
+
+        get(token) {
+            validateCapabilityToken(token);
+
+            if (!capabilities.has(token)) {
+                throw new Error(`sloppy: capability token is not declared
+
+Token:
+  ${token}
+
+Fix:
+  Add builder.capabilities.addDatabase(...) or a module .capabilities(...) declaration before build().`);
+            }
+
+            return snapshotCapability(capabilities.get(token));
+        },
+
+        list() {
+            return Object.freeze(Array.from(capabilities.values(), snapshotCapability));
+        },
+
+        __snapshot() {
+            return new Map(Array.from(capabilities.entries(), ([token, capability]) => [
+                token,
+                { ...capability, metadata: { ...capability.metadata } },
+            ]));
+        },
+
+        __runInModule(moduleName, callback) {
+            const previousModule = currentModule;
+            currentModule = moduleName;
+
+            try {
+                return callback(registry);
+            } finally {
+                currentModule = previousModule;
+            }
+        },
+    };
+
+    return Object.freeze(registry);
+}
+
+function createCapabilityProvider(capabilitySnapshot) {
+    return Object.freeze({
+        has(token) {
+            validateCapabilityToken(token);
+            return capabilitySnapshot.has(token);
+        },
+
+        get(token) {
+            validateCapabilityToken(token);
+
+            if (!capabilitySnapshot.has(token)) {
+                throw new Error(`sloppy: capability token is not declared
+
+Token:
+  ${token}
+
+Fix:
+  Check app.capabilities.list() or declare the capability before build().`);
+            }
+
+            return snapshotCapability(capabilitySnapshot.get(token));
+        },
+
+        list() {
+            return Object.freeze(Array.from(capabilitySnapshot.values(), snapshotCapability));
+        },
+    });
+}
+
+export {
+    createCapabilityProvider,
+    createCapabilityRegistry,
+};