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

package/templates/api/README.md

@@ -0,0 +1,82 @@
+# Sloppy API Starter
+
+This is the recommended public alpha, pre-production starter for building a
+backend with Sloppy. It shows routes, route modules, a small
+service/repository split, configuration, SQLite provider metadata, Schema
+request validation, health endpoints, and the app package flow.
+
+## Layout
+
+- `src/main.ts` wires the app, SQLite provider, middleware, services, and routes.
+- `src/routes/` contains route registration modules.
+- `src/services/` contains business logic.
+- `migrations/` contains first-party SQLite schema migration files.
+- `src/db/` contains runtime migration and repository helpers.
+- `src/models/` contains request and response shapes.
+- `public/` contains static assets served under `/public`.
+- `appsettings*.json` contains runtime configuration.
+- `data/` is where the development SQLite file is created.
+
+## Build And Inspect
+
+```sh
+sloppy build
+sloppy db migrate .sloppy --provider main
+sloppy routes .sloppy
+sloppy capabilities .sloppy
+sloppy doctor .sloppy
+sloppy audit .sloppy
+```
+
+## Run
+
+```sh
+sloppy run .sloppy --once GET /health
+sloppy run .sloppy --once GET /users
+sloppy run .sloppy --once GET /public/hello.txt
+sloppy run .sloppy --once POST /users --json "{\"name\":\"Katherine Johnson\",\"email\":\"katherine@example.test\"}"
+printf '{"name":"Katherine Johnson","email":"katherine@example.test"}' > user.json
+sloppy run .sloppy --header "content-type: application/json" --body-file user.json --once POST /users
+```
+
+```powershell
+Set-Content -Path user.json -Value '{"name":"Katherine Johnson","email":"katherine@example.test"}' -NoNewline
+sloppy run .sloppy --header "content-type: application/json" --body-file user.json --once POST /users
+```
+You can also run the development server and send requests with your HTTP
+client:
+
+```sh
+sloppy run .sloppy
+curl -X POST http://127.0.0.1:5173/users -H "content-type: application/json" -d "{\"name\":\"Katherine Johnson\",\"email\":\"katherine@example.test\"}"
+```
+
+Invalid JSON or invalid `name`/`email` fields return a `400
+application/problem+json` validation problem.
+
+Add `app.useErrors(...)` in `src/main.ts` when you want one explicit error
+policy for typed exception mappings, request IDs in error bodies, and redacted
+error logs.
+
+## Package
+
+```sh
+sloppy package
+sloppy db migrate .sloppy/package --provider main
+sloppy run .sloppy/package --once GET /health
+sloppy run .sloppy/package --once GET /users
+sloppy run .sloppy/package --once GET /public/hello.txt
+```
+
+The alpha package format contains the compiled Sloppy artifacts. The SQLite
+database path is configured as `data/app.db`; create that directory when you run
+the package from a directory that does not already have it. `/health/ready`
+performs a SQLite query after running the template migration.
+
+## Alpha Limits
+
+Sloppy is public alpha, pre-production software. SQLite is available through
+Sloppy's current provider bridge. The template uses
+`migrations/0001_create_users.sql` for schema setup and deterministic seed rows
+in code. Sloppy is not full Node, and this template does not require internet
+packages, Docker, external services, PostgreSQL, SQL Server, libpq, or ODBC.

package/templates/api/appsettings.Development.json

@@ -0,0 +1,14 @@
+{
+  "App": {
+    "Name": "Sloppy API Starter"
+  },
+  "Sloppy": {
+    "Logging": {
+      "MinimumLevel": "info",
+      "Console": {
+        "Enabled": true,
+        "Format": "pretty"
+      }
+    }
+  }
+}

package/templates/api/appsettings.json

@@ -0,0 +1,13 @@
+{
+  "Sloppy": {
+    "host": "127.0.0.1",
+    "port": 5173,
+    "Providers": {
+      "sqlite": {
+        "main": {
+          "database": "data/app.db"
+        }
+      }
+    }
+  }
+}

package/templates/api/data/.gitkeep

@@ -0,0 +1 @@
+

package/templates/api/gitignore

@@ -0,0 +1,4 @@
+.sloppy/
+node_modules/
+data/*.db
+data/*.db-*

package/templates/api/migrations/0001_create_users.sql

@@ -0,0 +1 @@
+create table if not exists users (id integer primary key, name text not null, email text not null unique)

package/templates/api/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "sloppy-api-starter",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "build": "sloppy build",
+    "run": "sloppy run .sloppy",
+    "package": "sloppy package",
+    "routes": "sloppy routes .sloppy",
+    "doctor": "sloppy doctor .sloppy",
+    "audit": "sloppy audit .sloppy"
+  },
+  "devDependencies": {
+    "@slopware/sloppy": "0.1.0-alpha.0"
+  }
+}

package/templates/api/public/hello.txt

@@ -0,0 +1 @@
+Hello from the Sloppy API template.

package/templates/api/sloppy.json

@@ -0,0 +1,14 @@
+{
+  "entry": "src/main.ts",
+  "outDir": ".sloppy",
+  "environment": "Development",
+  "capabilities": {
+    "fs": true
+  },
+  "migrations": {
+    "main": {
+      "provider": "sqlite",
+      "path": "migrations/*.sql"
+    }
+  }
+}

package/templates/api/src/config.ts

@@ -0,0 +1 @@
+export const appName = "Sloppy API Starter";

package/templates/api/src/db/migrate.ts

@@ -0,0 +1,14 @@
+import { Migrations } from "sloppy/data";
+import { seedUsers } from "./schema.ts";
+
+export async function migrateUsers(db) {
+    await Migrations.apply(db, { provider: "sqlite", path: "migrations/*.sql" });
+    await db.transaction(async (tx) => {
+        for (const user of seedUsers) {
+            await tx.exec(
+                "insert or ignore into users (id, name, email) values (?, ?, ?)",
+                user,
+            );
+        }
+    });
+}

package/templates/api/src/db/schema.ts

@@ -0,0 +1,4 @@
+export const seedUsers = [
+    [1, "Ada Lovelace", "ada@example.test"],
+    [2, "Grace Hopper", "grace@example.test"],
+];

package/templates/api/src/db/usersRepository.ts

@@ -0,0 +1,23 @@
+import { toUser } from "../models/user.ts";
+
+export async function repoListUsers(db) {
+    const rows = await db.query("select id, name, email from users order by id", []);
+    return rows.map(toUser);
+}
+
+export async function repoGetUserById(db, id) {
+    const row = await db.queryOne("select id, name, email from users where id = ?", [id]);
+    return row === null ? null : toUser(row);
+}
+
+export async function repoCreateUser(db, input) {
+    await db.exec("insert into users (name, email) values (?, ?)", [input.name, input.email]);
+    const row = await db.queryOne(
+        "select id, name, email from users where id = last_insert_rowid()",
+        [],
+    );
+    if (row === null) {
+        throw new Error("inserted user could not be loaded");
+    }
+    return toUser(row);
+}

package/templates/api/src/main.ts

@@ -0,0 +1,18 @@
+import { ProblemDetails, Sloppy } from "sloppy";
+import { sqlite } from "sloppy/providers/sqlite";
+import { healthModule } from "./routes/health.ts";
+import { usersModule } from "./routes/users.ts";
+
+const app = Sloppy.create();
+
+app.use(sqlite("main"));
+app.use(ProblemDetails.defaults({ detail: "never" }));
+app.useStaticFiles({
+    requestPath: "/public",
+    root: "public",
+    cache: { maxAgeSeconds: 60 },
+});
+app.useModule(usersModule);
+app.useModule(healthModule);
+
+export default app;

package/templates/api/src/models/user.ts

@@ -0,0 +1,7 @@
+export function toUser(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        email: row.email,
+    };
+}

package/templates/api/src/routes/health.ts

@@ -0,0 +1,20 @@
+import { Results } from "sloppy";
+import { migrateUsers } from "../db/migrate.ts";
+
+export function healthModule(app) {
+    const db = app.provider("sqlite:main");
+
+    app.get("/health", () => Results.text("ok"))
+        .withName("Health");
+
+    app.get("/health/live", () => Results.ok({ status: "healthy" }))
+        .withName("Health.Live");
+
+    app.get("/health/ready", async () => {
+        await migrateUsers(db);
+        const row = await db.queryOne("select 1 as ok", []);
+        return row === null
+            ? Results.status(503, { status: "unhealthy", checks: [{ name: "sqlite", status: "unhealthy" }] })
+            : Results.ok({ status: "healthy", checks: [{ name: "sqlite", status: "healthy" }] });
+    }).withName("Health.Ready");
+}

package/templates/api/src/routes/users.ts

@@ -0,0 +1,40 @@
+import { Results, Schema } from "sloppy";
+import {
+    createUser,
+    getUser,
+    listUsers,
+} from "../services/usersService.ts";
+
+export function usersModule(app) {
+    const db = app.provider("sqlite:main");
+    const CreateUser = Schema.object({
+        name: Schema.string().min(1).max(100),
+        email: Schema.string().email(),
+    });
+    const User = Schema.object({
+        id: Schema.integer(),
+        name: Schema.string(),
+        email: Schema.string(),
+    });
+
+    app.get("/users", async () => Results.ok(await listUsers(db)))
+        .withName("Users.List");
+
+    app.get("/users/{id:int}", async (ctx) => {
+        const user = await getUser(db, ctx.route.id);
+        if (user === null) {
+            return Results.notFound();
+        }
+        return Results.ok(user);
+    })
+        .withName("Users.Get");
+
+    app.post("/users", async (ctx) => {
+        const input = await ctx.body.validate(CreateUser);
+        const user = await createUser(db, input);
+        return Results.created(`/users/${user.id}`, user);
+    })
+        .accepts(CreateUser)
+        .returns(User, { status: 201 })
+        .withName("Users.Create");
+}

package/templates/api/src/services/usersService.ts

@@ -0,0 +1,21 @@
+import { migrateUsers } from "../db/migrate.ts";
+import {
+    repoCreateUser,
+    repoGetUserById,
+    repoListUsers,
+} from "../db/usersRepository.ts";
+
+export async function listUsers(db) {
+    await migrateUsers(db);
+    return repoListUsers(db);
+}
+
+export async function getUser(db, id) {
+    await migrateUsers(db);
+    return repoGetUserById(db, id);
+}
+
+export async function createUser(db, input) {
+    await migrateUsers(db);
+    return repoCreateUser(db, input);
+}

package/templates/api/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "allowImportingTsExtensions": true,
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "noEmit": true,
+    "target": "ES2022",
+    "types": [
+      "@slopware/sloppy"
+    ]
+  },
+  "include": [
+    "src/**/*.ts"
+  ]
+}

package/templates/cli/README.md

@@ -0,0 +1,16 @@
+# CLI Starter
+
+This public alpha, pre-production CLI starter is shaped like a practical local
+tool. It has a command dispatcher, subcommands, filesystem inspection, safe
+platform indicators, clear exit codes, and the packaged CLI flow.
+
+```sh
+sloppy run src/main.ts -- --help
+sloppy run src/main.ts -- echo hello
+sloppy run src/main.ts -- inspect package.json
+sloppy build
+sloppy package
+sloppy run .sloppy/package -- echo hello
+```
+
+Add commands under `src/commands/` and dispatch them from `src/main.ts`.

package/templates/cli/gitignore

@@ -0,0 +1,2 @@
+.sloppy/
+node_modules/

package/templates/cli/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "sloppy-cli-starter",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "build": "sloppy build",
+    "run": "sloppy run .sloppy -- --help",
+    "package": "sloppy package"
+  },
+  "devDependencies": {
+    "@slopware/sloppy": "0.1.0-alpha.0"
+  }
+}

package/templates/cli/sloppy.json

@@ -0,0 +1,6 @@
+{
+  "kind": "program",
+  "entry": "src/main.ts",
+  "outDir": ".sloppy",
+  "environment": "Development"
+}

package/templates/cli/src/commands/echo.ts

@@ -0,0 +1,9 @@
+export function echo(args) {
+    const text = args.join(" ");
+    if (text.length === 0) {
+        console.error("echo requires text");
+        return 1;
+    }
+    console.log(text);
+    return 0;
+}

package/templates/cli/src/commands/inspect.ts

@@ -0,0 +1,20 @@
+import { File } from "sloppy/fs";
+
+function filesystemPath(value) {
+    const path = value || "package.json";
+    if (path.startsWith("./") || path.startsWith("../") || path.includes(":/")) {
+        return path;
+    }
+    return `./${path}`;
+}
+
+export async function inspect(args) {
+    const path = filesystemPath(args[0]);
+    if (!(await File.exists(path))) {
+        console.error(`not found: ${path}`);
+        return 1;
+    }
+    const bytes = await File.readBytes(path);
+    console.log(JSON.stringify({ path, bytes: bytes.length }, null, 2));
+    return 0;
+}

package/templates/cli/src/main.ts

@@ -0,0 +1,50 @@
+import { Environment, System } from "sloppy/os";
+import { echo } from "./commands/echo.ts";
+import { inspect } from "./commands/inspect.ts";
+
+function printHelp() {
+    console.log("Usage: sloppy run .sloppy -- <command> [args]");
+    console.log("");
+    console.log("Commands:");
+    console.log("  --help             Show help");
+    console.log("  echo <text>        Print text");
+    console.log("  inspect <path>     Print basic file information");
+    console.log("  env                Print platform information");
+}
+
+function environmentIndicators(env) {
+    const source = env || {};
+    return {
+        HOME: source.HOME ? "set" : "unset",
+        USERPROFILE: source.USERPROFILE ? "set" : "unset",
+        SHELL: source.SHELL ? "set" : "unset",
+        COMSPEC: source.COMSPEC ? "set" : "unset",
+        CI: source.CI ? "set" : "unset",
+    };
+}
+
+export async function main(args, ctx) {
+    const command = args[0] || "--help";
+    if (command === "--help" || command === "help") {
+        printHelp();
+        return 0;
+    }
+    if (command === "echo") {
+        return echo(args.slice(1));
+    }
+    if (command === "inspect") {
+        return inspect(args.slice(1));
+    }
+    if (command === "env") {
+        console.log(JSON.stringify({
+            cwd: ctx.cwd,
+            environment: environmentIndicators(ctx.environment),
+            platform: System.platform,
+            homeSet: Boolean(Environment.get("HOME") || Environment.get("USERPROFILE")),
+        }, null, 2));
+        return 0;
+    }
+    console.error(`unknown command: ${command}`);
+    printHelp();
+    return 1;
+}

package/templates/cli/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "allowImportingTsExtensions": true,
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "noEmit": true,
+    "target": "ES2022",
+    "types": [
+      "@slopware/sloppy"
+    ]
+  },
+  "include": [
+    "src/**/*.ts"
+  ]
+}

package/templates/minimal-api/README.md

@@ -0,0 +1,14 @@
+# Minimal API Template
+
+This is the smallest public alpha, pre-production API starter. Use it for a
+quick first run or a smoke test; use `api` when you want a fuller backend
+layout.
+
+```sh
+sloppy build
+sloppy routes .sloppy
+sloppy run .sloppy --once GET /health
+sloppy run .sloppy --once GET /hello/Ada
+sloppy package
+sloppy run .sloppy/package --once GET /health
+```

package/templates/minimal-api/gitignore

@@ -0,0 +1,3 @@
+.sloppy/
+node_modules/
+*.db

package/templates/minimal-api/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "sloppy-minimal-api",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "build": "sloppy build",
+    "run": "sloppy run .sloppy",
+    "package": "sloppy package",
+    "routes": "sloppy routes .sloppy"
+  },
+  "devDependencies": {
+    "@slopware/sloppy": "0.1.0-alpha.0"
+  }
+}

package/templates/minimal-api/sloppy.json

@@ -0,0 +1,5 @@
+{
+  "entry": "src/main.ts",
+  "outDir": ".sloppy",
+  "environment": "Development"
+}

package/templates/minimal-api/src/main.ts

@@ -0,0 +1,9 @@
+import { Results, Sloppy } from "sloppy";
+
+const app = Sloppy.create();
+
+app.get("/health", () => Results.text("ok")).withName("Health.Get");
+app.get("/hello/{name}", (ctx) => Results.json({ hello: ctx.route.name }))
+    .withName("Hello.Get");
+
+export default app;

package/templates/minimal-api/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "allowImportingTsExtensions": true,
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "noEmit": true,
+    "target": "ES2022",
+    "types": [
+      "@slopware/sloppy"
+    ]
+  },
+  "include": [
+    "src/**/*.ts"
+  ]
+}

package/templates/node-compat/README.md

@@ -0,0 +1,40 @@
+# Node Compatibility Starter
+
+This public alpha, pre-production Program Mode starter demonstrates explicit
+supported Node compatibility shims. Sloppy is not full Node. Unsupported
+builtins fail clearly, and the shim set grows over time.
+
+This template uses:
+
+- `node:path`
+- `node:events`
+- `node:buffer`
+- `node:querystring`
+- `node:assert`
+- `node:process`
+- `node:stream` basics
+- `node:crypto` basics
+- `node:module`, `node:string_decoder`, `node:perf_hooks`, and other package
+  compatibility helpers are documented in the Node compatibility reference.
+
+It intentionally avoids full `node:http`, `node:net`, `node:tls`,
+`node:child_process`, native addons, and process-wide Node identity. Import
+compatibility modules explicitly in source. Bundled package programs may receive
+temporary `global`, `process`, and `Buffer` compatibility globals while the
+program entry runs.
+
+Pure-JavaScript npm packages that fit the documented exports/imports
+resolution shapes (see `tests/fixtures/npm-compat/matrix.json`) and exercise
+documented runtime behaviors (see `tests/fixtures/npm-runtime/matrix.json`)
+can be bundled alongside this template. The resolver matrix proves package
+shapes resolve; the runtime matrix proves selected package behaviors execute
+after packaging. Native addons, dynamic `require` without `moduleInclude`,
+and unsupported Node builtins are rejected with explicit diagnostics.
+
+```sh
+sloppy build
+sloppy deps .sloppy --explain
+sloppy run .sloppy
+sloppy package
+sloppy run .sloppy/package
+```

package/templates/node-compat/gitignore

@@ -0,0 +1,2 @@
+.sloppy/
+node_modules/

package/templates/node-compat/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "sloppy-node-compat-starter",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "build": "sloppy build",
+    "run": "sloppy run .sloppy",
+    "package": "sloppy package",
+    "deps": "sloppy deps .sloppy"
+  }
+}

package/templates/node-compat/sloppy.json

@@ -0,0 +1,6 @@
+{
+  "kind": "program",
+  "entry": "src/main.ts",
+  "outDir": ".sloppy",
+  "environment": "Development"
+}

package/templates/node-compat/src/main.ts

@@ -0,0 +1,40 @@
+import path from "node:path";
+import assert from "node:assert";
+import { Buffer } from "node:buffer";
+import crypto from "node:crypto";
+import { EventEmitter } from "node:events";
+import querystring from "node:querystring";
+import { Readable } from "node:stream";
+import process from "node:process";
+
+export async function main() {
+    const emitter = new EventEmitter();
+    let event = "missing";
+    emitter.on("ready", (value) => {
+        event = value;
+    });
+    emitter.emit("ready", "ok");
+
+    const query = querystring.parse("ready=true&mode=alpha");
+    const encoded = Buffer.from("sloppy").toString("utf8");
+    const euroCodePoint = Buffer.from([0xe2, 0x82, 0xac]).toString("utf8").codePointAt(0);
+    const digest = await crypto.createHash("sha256").update(encoded).digest("hex");
+    const chunks = [];
+    for await (const chunk of Readable.from(["node", "-", "compat"])) {
+        chunks.push(chunk);
+    }
+    assert.strictEqual(event, "ok");
+
+    console.log(JSON.stringify({
+        joined: path.join("src", "main.ts"),
+        event,
+        encoded,
+        euroCodePoint,
+        digestPrefix: digest.slice(0, 8),
+        ready: query.ready,
+        mode: query.mode,
+        platform: process.platform,
+        stream: chunks.join(""),
+    }, null, 2));
+    return 0;
+}