@pthm/melange 0.4.0

package/README.md

@@ -0,0 +1,44 @@
+# @pthm/melange
+
+TypeScript client for Melange PostgreSQL authorization.
+
+> **Note:** This package is a placeholder. The TypeScript runtime is not yet implemented.
+> Use the Go runtime (`github.com/pthm/melange/melange`) for production workloads.
+
+## Installation
+
+```bash
+npm install @pthm/melange
+```
+
+## Status
+
+This package provides:
+- Type definitions for authorization objects
+- Placeholder Checker class (throws "not implemented")
+
+The full implementation will include:
+- `Checker` class for permission checks
+- `Cache` for caching decisions
+- Connection pooling support
+
+## Generated Client Code
+
+You can generate type-safe client code from your schema using the melange CLI:
+
+```bash
+melange generate client --runtime typescript --schema schema.fga --output ./src/authz/
+```
+
+This generates:
+- Type constants (`TYPE_USER`, `TYPE_REPOSITORY`)
+- Relation constants (`REL_CAN_READ`, `REL_OWNER`)
+- Factory functions (`user()`, `repository()`)
+
+## Contributing
+
+See the [main repository](https://github.com/pthm/melange) for contribution guidelines.
+
+## License
+
+MIT

package/dist/checker.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Melange TypeScript Checker
+ *
+ * This module will provide the Checker class for performing authorization checks.
+ * Currently a placeholder - implementation coming in a future release.
+ */
+import type { MelangeObject, Relation, Decision } from './types.js';
+/**
+ * Checker performs authorization checks against a PostgreSQL database.
+ *
+ * @example
+ * ```typescript
+ * import { Checker } from '@pthm/melange';
+ * import { Pool } from 'pg';
+ *
+ * const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+ * const checker = new Checker(pool);
+ *
+ * const decision = await checker.check(
+ *   { type: 'user', id: '123' },
+ *   'can_read',
+ *   { type: 'repository', id: '456' }
+ * );
+ * ```
+ */
+export declare class Checker {
+    /**
+     * Creates a new Checker instance.
+     *
+     * @param db - A PostgreSQL client or pool with query capability
+     */
+    constructor(_db: unknown);
+    /**
+     * Check performs a permission check.
+     *
+     * @param subject - The subject requesting access
+     * @param relation - The relation to check
+     * @param object - The object being accessed
+     * @returns A Decision indicating whether access is allowed
+     */
+    check(_subject: MelangeObject, _relation: Relation, _object: MelangeObject): Promise<Decision>;
+}
+//# sourceMappingURL=checker.d.ts.map

package/dist/checker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checker.d.ts","sourceRoot":"","sources":["../src/checker.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEpE;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,OAAO;IAClB;;;;OAIG;gBACS,GAAG,EAAE,OAAO;IAOxB;;;;;;;OAOG;IACG,KAAK,CACT,QAAQ,EAAE,aAAa,EACvB,SAAS,EAAE,QAAQ,EACnB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,QAAQ,CAAC;CAGrB"}

package/dist/checker.js

@@ -0,0 +1,47 @@
+/**
+ * Melange TypeScript Checker
+ *
+ * This module will provide the Checker class for performing authorization checks.
+ * Currently a placeholder - implementation coming in a future release.
+ */
+/**
+ * Checker performs authorization checks against a PostgreSQL database.
+ *
+ * @example
+ * ```typescript
+ * import { Checker } from '@pthm/melange';
+ * import { Pool } from 'pg';
+ *
+ * const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+ * const checker = new Checker(pool);
+ *
+ * const decision = await checker.check(
+ *   { type: 'user', id: '123' },
+ *   'can_read',
+ *   { type: 'repository', id: '456' }
+ * );
+ * ```
+ */
+export class Checker {
+    /**
+     * Creates a new Checker instance.
+     *
+     * @param db - A PostgreSQL client or pool with query capability
+     */
+    constructor(_db) {
+        throw new Error('Melange TypeScript runtime is not yet implemented. ' +
+            'Use the Go runtime (github.com/pthm/melange/melange) for now.');
+    }
+    /**
+     * Check performs a permission check.
+     *
+     * @param subject - The subject requesting access
+     * @param relation - The relation to check
+     * @param object - The object being accessed
+     * @returns A Decision indicating whether access is allowed
+     */
+    async check(_subject, _relation, _object) {
+        throw new Error('Not implemented');
+    }
+}
+//# sourceMappingURL=checker.js.map

package/dist/checker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checker.js","sourceRoot":"","sources":["../src/checker.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,OAAO,OAAO;IAClB;;;;OAIG;IACH,YAAY,GAAY;QACtB,MAAM,IAAI,KAAK,CACb,qDAAqD;YACrD,+DAA+D,CAChE,CAAC;IACJ,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,KAAK,CACT,QAAuB,EACvB,SAAmB,EACnB,OAAsB;QAEtB,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;IACrC,CAAC;CACF"}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @pthm/melange - TypeScript client for Melange PostgreSQL authorization
+ *
+ * Melange is an OpenFGA-compatible authorization library that runs entirely
+ * in PostgreSQL. This TypeScript client provides type-safe access to the
+ * authorization system.
+ *
+ * @packageDocumentation
+ */
+export { Checker } from './checker.js';
+export type { ObjectType, Relation, MelangeObject, Decision, CheckRequest, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,YAAY,EACV,UAAU,EACV,QAAQ,EACR,aAAa,EACb,QAAQ,EACR,YAAY,GACb,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,11 @@
+/**
+ * @pthm/melange - TypeScript client for Melange PostgreSQL authorization
+ *
+ * Melange is an OpenFGA-compatible authorization library that runs entirely
+ * in PostgreSQL. This TypeScript client provides type-safe access to the
+ * authorization system.
+ *
+ * @packageDocumentation
+ */
+export { Checker } from './checker.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Melange TypeScript Types
+ *
+ * This module provides type definitions for Melange authorization checks.
+ * Types are designed to match the Go runtime for cross-language consistency.
+ */
+/**
+ * ObjectType represents an authorization object type (e.g., "user", "repository").
+ */
+export type ObjectType = string;
+/**
+ * Relation represents an authorization relation (e.g., "owner", "can_read").
+ */
+export type Relation = string;
+/**
+ * Object represents an authorization object with type and ID.
+ */
+export interface MelangeObject {
+    readonly type: ObjectType;
+    readonly id: string;
+}
+/**
+ * Decision represents the result of a permission check.
+ */
+export interface Decision {
+    readonly allowed: boolean;
+}
+/**
+ * CheckRequest represents a permission check request.
+ */
+export interface CheckRequest {
+    readonly subject: MelangeObject;
+    readonly relation: Relation;
+    readonly object: MelangeObject;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC;AAEhC;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC;AAE9B;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;IAChC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;CAChC"}

package/dist/types.js

@@ -0,0 +1,8 @@
+/**
+ * Melange TypeScript Types
+ *
+ * This module provides type definitions for Melange authorization checks.
+ * Types are designed to match the Go runtime for cross-language consistency.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@pthm/melange",
+  "version": "0.4.0",
+  "description": "TypeScript client for Melange PostgreSQL authorization",
+  "keywords": [
+    "authorization",
+    "fga",
+    "openfga",
+    "postgresql",
+    "melange"
+  ],
+  "author": "pthm",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pthm/melange.git",
+    "directory": "clients/typescript"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}