@supawatch/target-schema-lock 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Omar Dulaimi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,19 @@
+# @supawatch/target-schema-lock
+
+The schema lockfile target for
+[supawatch](https://github.com/omar-dulaimi/supawatch). Emits
+`schema.lock.json`: a canonical, byte-stable snapshot of your schema meant
+to be committed.
+
+Configure it in `supawatch.config.ts` (the CLI loads this package by name):
+
+```ts
+targets: [{ kind: "schema-lock" }]
+```
+
+Why commit it: `supawatch check` then catches schema drift the same way it
+catches stale generated files, and the lockfile's diff in a pull request IS
+the schema changelog reviewers read. Ordering is canonicalized (sorted keys
+and collections), so an unchanged schema produces identical bytes.
+
+MIT.

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import type { Snapshot, SnapshotFile, Target, TargetCapabilities, TargetOptions } from "@supawatch/core";
+export type SchemaLockTargetOptions = TargetOptions;
+export declare class SchemaLockTarget implements Target<SchemaLockTargetOptions> {
+    readonly name = "schema-lock";
+    readonly fileExtension = ".json";
+    readonly barrel = false;
+    readonly capabilities: TargetCapabilities;
+    renderTable(): never;
+    renderSnapshot(snapshot: Snapshot, _opts: SchemaLockTargetOptions): SnapshotFile[];
+}
+export default SchemaLockTarget;

package/dist/index.js

@@ -0,0 +1,45 @@
+const FORMAT = 1;
+// Canonicalize: sort every object's keys and every named collection, so
+// the file is byte-stable for an unchanged schema regardless of catalog
+// ordering.
+function canonical(value) {
+    if (Array.isArray(value))
+        return value.map(canonical);
+    if (value && typeof value === "object") {
+        const out = {};
+        for (const key of Object.keys(value).sort()) {
+            out[key] = canonical(value[key]);
+        }
+        return out;
+    }
+    return value;
+}
+function sortByName(xs) {
+    return [...xs].sort((a, b) => `${a.schema ?? ""}.${a.name}`.localeCompare(`${b.schema ?? ""}.${b.name}`));
+}
+export class SchemaLockTarget {
+    name = "schema-lock";
+    fileExtension = ".json";
+    barrel = false;
+    capabilities = {
+        strictObjects: false,
+        brandedTypes: false,
+        dateInstances: false,
+    };
+    renderTable() {
+        throw new Error("schema-lock is a snapshot-level target");
+    }
+    renderSnapshot(snapshot, _opts) {
+        const body = canonical({
+            format: FORMAT,
+            tables: sortByName(snapshot.tables),
+            enums: sortByName(snapshot.enums),
+            domains: sortByName(snapshot.domains),
+            composites: sortByName(snapshot.composites),
+        });
+        return [
+            { file: "schema.lock.json", content: JSON.stringify(body, null, 2) + "\n" },
+        ];
+    }
+}
+export default SchemaLockTarget;

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@supawatch/target-schema-lock",
+  "version": "0.2.0",
+  "description": "A canonical committed schema lockfile from supawatch, turning pull-request diffs into schema changelogs.",
+  "keywords": [
+    "supabase",
+    "postgres",
+    "postgresql",
+    "codegen",
+    "schema",
+    "typescript",
+    "lockfile",
+    "drift",
+    "ci"
+  ],
+  "license": "MIT",
+  "author": "Omar Dulaimi",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/omar-dulaimi/supawatch.git",
+    "directory": "packages/target-schema-lock"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@supawatch/core": "0.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.1",
+    "typescript": "^5.9.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  }
+}