@party-stack/ontology 0.19.1 → 0.21.0

package/lib/authentication.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authentication.d.ts","names":["_$__tanstack_descriptors_js0.OntologyCollectionDescriptors","AccountRef"],"sources":["../src/authentication.ts"],"mappings":";;;;;;;;;;;qBAewB,uBAOtBA,mEAP2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAO3C;iBAGe;WACJ,QACH,uBACA,OAAO,OAAO,iBAAiB,sBAAsB,cAAc,MAAM;WACtE;WACA,UAAU;;;;;;wBAOD,2BAA2B,SAAS,8BAA2B;EAyBjD,MAAA,UAAA,YAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGE,SAAA,WAAA,YAAU,QAAA,YAAA;;;;;;;;;;;;;;;;;;OAAqB,gXAAG;;;;;;;;;;;;;;IAEtC,WAAA,gBAAM;;;;;;;;;;;;;;;EAGI,wBAAA,kBAAM,oBAAiB;;;;EAE/B,gBAAA,kBAAM,gBAAa;;;;EAE1B,UAAA,SAAAC,iBAAU;EACX,SAAA,SAAAA,iBAAU;;;;YAapC,uBAAuB,QAAQ,kBAAkB"}

package/lib/authentication.js

@@ -0,0 +1,55 @@
+import { ontologyCollections } from "./tanstack/descriptors.js";
+import { makeAuthenticationClient } from "@party-stack/connect";
+import { classifyBackendFailure } from "@party-stack/ontology-backend";
+import { MemoryRuntime, Runtimes } from "@party-stack/runtime";
+import { Effect, Exit, Fiber, Layer, Scope } from "effect";
+//#region src/authentication.ts
+/** Collection descriptors for live queries over Connect's saved accounts and
+* configuration. Resolve them through the authentication view's DbClient.
+* Importing descriptors does not open a client or grant access to secret fields.
+*/
+const { objects: authenticationObjects } = ontologyCollections({
+	ServiceInstance: "id",
+	OAuthApplication: "id",
+	OAuthConnection: "id",
+	ApiKeyConnection: "id",
+	ExternalSessionConnection: "id",
+	OAuthAuthorizationAttempt: "id"
+});
+/** Promise browser commands over the selected Connect ontology. Inventory is read
+* from its ordinary Query endpoint; no account stream or authentication-method proxy.
+* Authentication workflows execute directly and never enter an optimistic outbox.
+*/
+async function createAuthenticationClient(options) {
+	const scope = Effect.runSync(Scope.make());
+	return Effect.runPromise(Scope.provide(Effect.gen(function* () {
+		const environment = yield* Layer.build(options.runtime ?? Runtimes.layer(MemoryRuntime.layer));
+		const browserAuthentication = (yield* Runtimes.pipe(Effect.provideContext(environment))).browserAuthentication;
+		const remote = yield* Effect.isEffect(options.client) ? options.client : Effect.succeed(options.client);
+		const client = "ontology" in remote ? yield* remote.ontology(options.ontology ?? "connect") : remote;
+		const run = (work) => Effect.runPromise(Effect.acquireUseRelease(Effect.forkIn(work, scope, { startImmediately: true }), Fiber.join, Fiber.interrupt));
+		const commands = makeAuthenticationClient({
+			backend: client.backend,
+			browserAuthentication
+		});
+		return {
+			oauth(settings) {
+				const oauth = commands.oauth(settings);
+				return {
+					signIn: (settings) => run(oauth.signIn(settings)),
+					complete: (url) => run(oauth.complete(url))
+				};
+			},
+			attachExternalSession: (instance, session) => run(commands.attachExternalSession(instance, session)),
+			connectApiKey: (instance, key) => run(commands.connectApiKey(instance, key)),
+			signOut: (account) => run(commands.signOut(account)),
+			forget: (account) => run(commands.forget(account)),
+			connections: () => run(commands.connections),
+			cleanup: () => Effect.runPromise(Scope.close(scope, Exit.void))
+		};
+	}), scope).pipe(Effect.mapError((error) => classifyBackendFailure("connect.client", error)), Effect.onExit((exit) => Exit.isFailure(exit) ? Scope.close(scope, exit) : Effect.void)));
+}
+//#endregion
+export { authenticationObjects, createAuthenticationClient };
+
+//# sourceMappingURL=authentication.js.map

package/lib/authentication.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"authentication.js","names":[],"sources":["../src/authentication.ts"],"sourcesContent":["import { makeAuthenticationClient } from \"@party-stack/connect\";\nimport { classifyBackendFailure } from \"@party-stack/ontology-backend\";\nimport { MemoryRuntime, Runtimes } from \"@party-stack/runtime\";\nimport { Effect, Exit, Fiber, Layer, Scope } from \"effect\";\nimport { ontologyCollections } from \"./tanstack/descriptors.js\";\nimport type { AccountRef } from \"@party-stack/connect\";\nimport type { ConnectOntology } from \"@party-stack/connect/spec\";\nimport type { BackendError } from \"@party-stack/ontology-backend\";\nimport type { OntologyClient, OntologyServerClient } from \"@party-stack/ontology-server/rpc\";\nimport type { RuntimesLayer } from \"@party-stack/runtime\";\n\n/** Collection descriptors for live queries over Connect's saved accounts and\n * configuration. Resolve them through the authentication view's DbClient.\n * Importing descriptors does not open a client or grant access to secret fields.\n */\nexport const { objects: authenticationObjects } = ontologyCollections<ConnectOntology>({\n    ServiceInstance: \"id\",\n    OAuthApplication: \"id\",\n    OAuthConnection: \"id\",\n    ApiKeyConnection: \"id\",\n    ExternalSessionConnection: \"id\",\n    OAuthAuthorizationAttempt: \"id\",\n});\nexport type { AccountRef, AccountSummary } from \"@party-stack/connect\";\n\nexport interface AuthenticationClientOptions {\n    readonly client:\n        | OntologyServerClient\n        | Effect.Effect<OntologyClient | OntologyServerClient, BackendError, Scope.Scope>;\n    readonly ontology?: string;\n    readonly runtime?: RuntimesLayer;\n}\n\n/** Promise browser commands over the selected Connect ontology. Inventory is read\n * from its ordinary Query endpoint; no account stream or authentication-method proxy.\n * Authentication workflows execute directly and never enter an optimistic outbox.\n */\nexport async function createAuthenticationClient(options: AuthenticationClientOptions) {\n    const scope = Effect.runSync(Scope.make());\n    return Effect.runPromise(\n        Scope.provide(\n            Effect.gen(function* () {\n                const environment = yield* Layer.build(\n                    options.runtime ?? Runtimes.layer(MemoryRuntime.layer)\n                );\n                const browserAuthentication = (yield* Runtimes.pipe(Effect.provideContext(environment)))\n                    .browserAuthentication;\n                const remote = yield* Effect.isEffect(options.client)\n                    ? options.client\n                    : Effect.succeed(options.client);\n                const client =\n                    \"ontology\" in remote ? yield* remote.ontology(options.ontology ?? \"connect\") : remote;\n                const run = <A, E>(work: Effect.Effect<A, E>) =>\n                    Effect.runPromise(\n                        Effect.acquireUseRelease(\n                            Effect.forkIn(work, scope, { startImmediately: true }),\n                            Fiber.join,\n                            Fiber.interrupt\n                        )\n                    );\n                const commands = makeAuthenticationClient({ backend: client.backend, browserAuthentication });\n                return {\n                    oauth(settings: Parameters<typeof commands.oauth>[0]) {\n                        const oauth = commands.oauth(settings);\n                        return {\n                            signIn: (settings?: Parameters<typeof oauth.signIn>[0]) =>\n                                run(oauth.signIn(settings)),\n                            complete: (url: string) => run(oauth.complete(url)),\n                        };\n                    },\n                    attachExternalSession: (instance: string, session: string) =>\n                        run(commands.attachExternalSession(instance, session)),\n                    connectApiKey: (instance: string, key: string) =>\n                        run(commands.connectApiKey(instance, key)),\n                    signOut: (account: AccountRef) => run(commands.signOut(account)),\n                    forget: (account: AccountRef) => run(commands.forget(account)),\n                    connections: () => run(commands.connections),\n                    cleanup: () => Effect.runPromise(Scope.close(scope, Exit.void)),\n                };\n            }),\n            scope\n        ).pipe(\n            Effect.mapError((error) => classifyBackendFailure(\"connect.client\", error)),\n            Effect.onExit((exit) => (Exit.isFailure(exit) ? Scope.close(scope, exit) : Effect.void))\n        )\n    );\n}\n\nexport type AuthenticationClient = Awaited<ReturnType<typeof createAuthenticationClient>>;\n"],"mappings":";;;;;;;;;;AAeA,MAAa,EAAE,SAAS,0BAA0B,oBAAqC;CACnF,iBAAiB;CACjB,kBAAkB;CAClB,iBAAiB;CACjB,kBAAkB;CAClB,2BAA2B;CAC3B,2BAA2B;AAC/B,CAAC;;;;;AAeD,eAAsB,2BAA2B,SAAsC;CACnF,MAAM,QAAQ,OAAO,QAAQ,MAAM,KAAK,CAAC;CACzC,OAAO,OAAO,WACV,MAAM,QACF,OAAO,IAAI,aAAa;EACpB,MAAM,cAAc,OAAO,MAAM,MAC7B,QAAQ,WAAW,SAAS,MAAM,cAAc,KAAK,CACzD;EACA,MAAM,yBAAyB,OAAO,SAAS,KAAK,OAAO,eAAe,WAAW,CAAC,EAAA,CACjF;EACL,MAAM,SAAS,OAAO,OAAO,SAAS,QAAQ,MAAM,IAC9C,QAAQ,SACR,OAAO,QAAQ,QAAQ,MAAM;EACnC,MAAM,SACF,cAAc,SAAS,OAAO,OAAO,SAAS,QAAQ,YAAY,SAAS,IAAI;EACnF,MAAM,OAAa,SACf,OAAO,WACH,OAAO,kBACH,OAAO,OAAO,MAAM,OAAO,EAAE,kBAAkB,KAAK,CAAC,GACrD,MAAM,MACN,MAAM,SACV,CACJ;EACJ,MAAM,WAAW,yBAAyB;GAAE,SAAS,OAAO;GAAS;EAAsB,CAAC;EAC5F,OAAO;GACH,MAAM,UAAgD;IAClD,MAAM,QAAQ,SAAS,MAAM,QAAQ;IACrC,OAAO;KACH,SAAS,aACL,IAAI,MAAM,OAAO,QAAQ,CAAC;KAC9B,WAAW,QAAgB,IAAI,MAAM,SAAS,GAAG,CAAC;IACtD;GACJ;GACA,wBAAwB,UAAkB,YACtC,IAAI,SAAS,sBAAsB,UAAU,OAAO,CAAC;GACzD,gBAAgB,UAAkB,QAC9B,IAAI,SAAS,cAAc,UAAU,GAAG,CAAC;GAC7C,UAAU,YAAwB,IAAI,SAAS,QAAQ,OAAO,CAAC;GAC/D,SAAS,YAAwB,IAAI,SAAS,OAAO,OAAO,CAAC;GAC7D,mBAAmB,IAAI,SAAS,WAAW;GAC3C,eAAe,OAAO,WAAW,MAAM,MAAM,OAAO,KAAK,IAAI,CAAC;EAClE;CACJ,CAAC,GACD,KACJ,CAAC,CAAC,KACE,OAAO,UAAU,UAAU,uBAAuB,kBAAkB,KAAK,CAAC,GAC1E,OAAO,QAAQ,SAAU,KAAK,UAAU,IAAI,IAAI,MAAM,MAAM,OAAO,IAAI,IAAI,OAAO,IAAK,CAC3F,CACJ;AACJ"}

package/lib/cli/index.js

@@ -1,52 +1,26 @@
 #!/usr/bin/env node
-import { generateFiles } from "./generate.js";
 import { ONTOLOGY_IR_PATH, ONTOLOGY_PULL_CONFIG_PATH, discoverOntologyPullConfigPath, loadOntologyPullConfig, writePulledOntology } from "./pull.js";
-import { pascalCase } from "change-case";
-import { existsSync, readFileSync } from "node:fs";
-import { basename, resolve } from "node:path";
-import { Command } from "commander";
+import { Console, Effect } from "effect";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { NodeRuntime, NodeServices } from "@effect/platform-node";
+import { makeGenerateCommand } from "@party-stack/ontology-spec/generate";
+import { CliError, Command } from "effect/cli";
 //#region src/cli/index.ts
-const GENERATED_DIR_PATH = "src/ontology/generated";
-function readPackageNamespace(cwd) {
-	const packageJsonPath = resolve(cwd, "package.json");
-	if (!existsSync(packageJsonPath)) return pascalCase(basename(cwd));
-	try {
-		const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-		const packageName = typeof packageJson.name === "string" ? packageJson.name.split("/").pop() ?? packageJson.name : basename(cwd);
-		return pascalCase(packageName);
-	} catch {
-		return pascalCase(basename(cwd));
-	}
-}
-async function main() {
-	const cwd = process.cwd();
-	const ontologyPath = resolve(cwd, ONTOLOGY_IR_PATH);
-	const generatedDir = resolve(cwd, GENERATED_DIR_PATH);
-	const program = new Command();
-	program.name("ontology").description("Generate and pull ontology files");
-	program.command("generate").description("Generate ontology types, builders, and live helpers").option("--ontology <path>", "Path to the ontology module", ontologyPath).option("--outDir <path>", "Directory to write generated files", generatedDir).option("--namespace <name>", "Namespace for generated ontology types/factories").option("--no-js-extensions", "Omit .js extensions from generated relative imports").action(async (options) => {
-		await generateFiles({
-			ontology: resolve(cwd, options.ontology),
-			outDir: resolve(cwd, options.outDir),
-			namespace: options.namespace ?? readPackageNamespace(cwd),
-			jsExtensions: options.jsExtensions
-		});
-	});
-	const configPath = discoverOntologyPullConfigPath(cwd);
-	if (configPath) program.command("pull").description(`Pull ontology metadata using ${ONTOLOGY_PULL_CONFIG_PATH}`).action(async () => {
+const { version } = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8"));
+const configPath = discoverOntologyPullConfigPath(process.cwd());
+const pull = Command.make("pull", {}, () => Effect.tryPromise({
+	try: async () => {
+		if (!configPath) throw new Error(`Create ${ONTOLOGY_PULL_CONFIG_PATH} before pulling metadata.`);
 		const config = await loadOntologyPullConfig(configPath);
-		const { createNodeRuntime } = await import("@party-stack/node-runtime");
-		await writePulledOntology(config, ontologyPath, { runtime: createNodeRuntime });
-		console.log(`Generated ontology written to: ${ontologyPath}`);
-	});
-	await program.parseAsync();
-}
-main().then(() => {
-	process.exit(0);
-}).catch((error) => {
-	console.error(error instanceof Error ? error.message : String(error));
-	process.exit(1);
-});
+		const { nodeRuntime } = await import("@party-stack/node-runtime");
+		const path = resolve(process.cwd(), ONTOLOGY_IR_PATH);
+		await writePulledOntology(config, path, { runtime: nodeRuntime() });
+		return path;
+	},
+	catch: (cause) => new CliError.UserError({ cause })
+}).pipe(Effect.flatMap((path) => Console.log(`Generated ontology written to: ${path}`)))).pipe(Command.withDescription(`Pull ontology metadata using ${ONTOLOGY_PULL_CONFIG_PATH}`));
+Command.make("ontology").pipe(Command.withDescription("Generate and pull ontology files"), Command.withSubcommands([makeGenerateCommand({ valuesImportPath: "@party-stack/ontology/values" }), ...configPath ? [pull] : []]), Command.run({ version }), Effect.provide(NodeServices.layer), NodeRuntime.runMain);
 //#endregion
 export {};
 

package/lib/cli/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/cli/index.ts"],"sourcesContent":["#!/usr/bin/env node\nimport { existsSync, readFileSync } from \"node:fs\";\nimport { basename, resolve } from \"node:path\";\nimport { pascalCase } from \"change-case\";\nimport { Command } from \"commander\";\nimport { generateFiles } from \"./generate.js\";\nimport {\n    ONTOLOGY_PULL_CONFIG_PATH,\n    ONTOLOGY_IR_PATH,\n    discoverOntologyPullConfigPath,\n    loadOntologyPullConfig,\n    writePulledOntology,\n} from \"./pull.js\";\n\nconst GENERATED_DIR_PATH = \"src/ontology/generated\";\n\nfunction readPackageNamespace(cwd: string): string {\n    const packageJsonPath = resolve(cwd, \"package.json\");\n    if (!existsSync(packageJsonPath)) {\n        return pascalCase(basename(cwd));\n    }\n\n    try {\n        const packageJson = JSON.parse(readFileSync(packageJsonPath, \"utf-8\")) as { name?: unknown };\n        const packageName =\n            typeof packageJson.name === \"string\"\n                ? (packageJson.name.split(\"/\").pop() ?? packageJson.name)\n                : basename(cwd);\n        return pascalCase(packageName);\n    } catch {\n        return pascalCase(basename(cwd));\n    }\n}\n\nasync function main(): Promise<void> {\n    const cwd = process.cwd();\n    const ontologyPath = resolve(cwd, ONTOLOGY_IR_PATH);\n    const generatedDir = resolve(cwd, GENERATED_DIR_PATH);\n    const program = new Command();\n\n    program.name(\"ontology\").description(\"Generate and pull ontology files\");\n\n    program\n        .command(\"generate\")\n        .description(\"Generate ontology types, builders, and live helpers\")\n        .option(\"--ontology <path>\", \"Path to the ontology module\", ontologyPath)\n        .option(\"--outDir <path>\", \"Directory to write generated files\", generatedDir)\n        .option(\"--namespace <name>\", \"Namespace for generated ontology types/factories\")\n        .option(\"--no-js-extensions\", \"Omit .js extensions from generated relative imports\")\n        .action(\n            async (options: {\n                ontology: string;\n                outDir: string;\n                namespace?: string;\n                jsExtensions?: boolean;\n            }) => {\n                await generateFiles({\n                    ontology: resolve(cwd, options.ontology),\n                    outDir: resolve(cwd, options.outDir),\n                    namespace: options.namespace ?? readPackageNamespace(cwd),\n                    jsExtensions: options.jsExtensions,\n                });\n            }\n        );\n\n    const configPath = discoverOntologyPullConfigPath(cwd);\n    if (configPath) {\n        program\n            .command(\"pull\")\n            .description(`Pull ontology metadata using ${ONTOLOGY_PULL_CONFIG_PATH}`)\n            .action(async () => {\n                const config = await loadOntologyPullConfig(configPath);\n                const { createNodeRuntime } = await import(\"@party-stack/node-runtime\");\n                await writePulledOntology(config, ontologyPath, {\n                    runtime: createNodeRuntime,\n                });\n                console.log(`Generated ontology written to: ${ontologyPath}`);\n            });\n    }\n\n    await program.parseAsync();\n}\n\nmain()\n    .then(() => {\n        process.exit(0);\n    })\n    .catch((error) => {\n        console.error(error instanceof Error ? error.message : String(error));\n        process.exit(1);\n    });\n"],"mappings":";;;;;;;;AAcA,MAAM,qBAAqB;AAE3B,SAAS,qBAAqB,KAAqB;CAC/C,MAAM,kBAAkB,QAAQ,KAAK,cAAc;CACnD,IAAI,CAAC,WAAW,eAAe,GAC3B,OAAO,WAAW,SAAS,GAAG,CAAC;CAGnC,IAAI;EACA,MAAM,cAAc,KAAK,MAAM,aAAa,iBAAiB,OAAO,CAAC;EACrE,MAAM,cACF,OAAO,YAAY,SAAS,WACrB,YAAY,KAAK,MAAM,GAAG,CAAC,CAAC,IAAI,KAAK,YAAY,OAClD,SAAS,GAAG;EACtB,OAAO,WAAW,WAAW;CACjC,QAAQ;EACJ,OAAO,WAAW,SAAS,GAAG,CAAC;CACnC;AACJ;AAEA,eAAe,OAAsB;CACjC,MAAM,MAAM,QAAQ,IAAI;CACxB,MAAM,eAAe,QAAQ,KAAK,gBAAgB;CAClD,MAAM,eAAe,QAAQ,KAAK,kBAAkB;CACpD,MAAM,UAAU,IAAI,QAAQ;CAE5B,QAAQ,KAAK,UAAU,CAAC,CAAC,YAAY,kCAAkC;CAEvE,QACK,QAAQ,UAAU,CAAC,CACnB,YAAY,qDAAqD,CAAC,CAClE,OAAO,qBAAqB,+BAA+B,YAAY,CAAC,CACxE,OAAO,mBAAmB,sCAAsC,YAAY,CAAC,CAC7E,OAAO,sBAAsB,kDAAkD,CAAC,CAChF,OAAO,sBAAsB,qDAAqD,CAAC,CACnF,OACG,OAAO,YAKD;EACF,MAAM,cAAc;GAChB,UAAU,QAAQ,KAAK,QAAQ,QAAQ;GACvC,QAAQ,QAAQ,KAAK,QAAQ,MAAM;GACnC,WAAW,QAAQ,aAAa,qBAAqB,GAAG;GACxD,cAAc,QAAQ;EAC1B,CAAC;CACL,CACJ;CAEJ,MAAM,aAAa,+BAA+B,GAAG;CACrD,IAAI,YACA,QACK,QAAQ,MAAM,CAAC,CACf,YAAY,gCAAgC,2BAA2B,CAAC,CACxE,OAAO,YAAY;EAChB,MAAM,SAAS,MAAM,uBAAuB,UAAU;EACtD,MAAM,EAAE,sBAAsB,MAAM,OAAO;EAC3C,MAAM,oBAAoB,QAAQ,cAAc,EAC5C,SAAS,kBACb,CAAC;EACD,QAAQ,IAAI,kCAAkC,cAAc;CAChE,CAAC;CAGT,MAAM,QAAQ,WAAW;AAC7B;AAEA,KAAK,CAAC,CACD,WAAW;CACR,QAAQ,KAAK,CAAC;AAClB,CAAC,CAAC,CACD,OAAO,UAAU;CACd,QAAQ,MAAM,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,CAAC;CACpE,QAAQ,KAAK,CAAC;AAClB,CAAC"}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/cli/index.ts"],"sourcesContent":["#!/usr/bin/env node\nimport { readFileSync } from \"node:fs\";\nimport { resolve } from \"node:path\";\nimport { NodeRuntime, NodeServices } from \"@effect/platform-node\";\nimport { makeGenerateCommand } from \"@party-stack/ontology-spec/generate\";\nimport { Console, Effect } from \"effect\";\nimport { CliError, Command } from \"effect/cli\";\nimport {\n    ONTOLOGY_PULL_CONFIG_PATH,\n    ONTOLOGY_IR_PATH,\n    discoverOntologyPullConfigPath,\n    loadOntologyPullConfig,\n    writePulledOntology,\n} from \"./pull.js\";\n\nconst { version } = JSON.parse(readFileSync(new URL(\"../../package.json\", import.meta.url), \"utf8\")) as {\n    version: string;\n};\n\nconst configPath = discoverOntologyPullConfigPath(process.cwd());\nconst pull = Command.make(\"pull\", {}, () =>\n    Effect.tryPromise({\n        try: async () => {\n            if (!configPath) throw new Error(`Create ${ONTOLOGY_PULL_CONFIG_PATH} before pulling metadata.`);\n            const config = await loadOntologyPullConfig(configPath);\n            const { nodeRuntime } = await import(\"@party-stack/node-runtime\");\n            const path = resolve(process.cwd(), ONTOLOGY_IR_PATH);\n            await writePulledOntology(config, path, { runtime: nodeRuntime() });\n            return path;\n        },\n        catch: (cause) => new CliError.UserError({ cause }),\n    }).pipe(Effect.flatMap((path) => Console.log(`Generated ontology written to: ${path}`)))\n).pipe(Command.withDescription(`Pull ontology metadata using ${ONTOLOGY_PULL_CONFIG_PATH}`));\n\nCommand.make(\"ontology\").pipe(\n    Command.withDescription(\"Generate and pull ontology files\"),\n    Command.withSubcommands([\n        makeGenerateCommand({ valuesImportPath: \"@party-stack/ontology/values\" }),\n        ...(configPath ? [pull] : []),\n    ]),\n    Command.run({ version }),\n    Effect.provide(NodeServices.layer),\n    NodeRuntime.runMain\n);\n"],"mappings":";;;;;;;;;AAeA,MAAM,EAAE,YAAY,KAAK,MAAM,aAAa,IAAI,IAAI,sBAAsB,YAAY,GAAG,GAAG,MAAM,CAAC;AAInG,MAAM,aAAa,+BAA+B,QAAQ,IAAI,CAAC;AAC/D,MAAM,OAAO,QAAQ,KAAK,QAAQ,CAAC,SAC/B,OAAO,WAAW;CACd,KAAK,YAAY;EACb,IAAI,CAAC,YAAY,MAAM,IAAI,MAAM,UAAU,0BAA0B,0BAA0B;EAC/F,MAAM,SAAS,MAAM,uBAAuB,UAAU;EACtD,MAAM,EAAE,gBAAgB,MAAM,OAAO;EACrC,MAAM,OAAO,QAAQ,QAAQ,IAAI,GAAG,gBAAgB;EACpD,MAAM,oBAAoB,QAAQ,MAAM,EAAE,SAAS,YAAY,EAAE,CAAC;EAClE,OAAO;CACX;CACA,QAAQ,UAAU,IAAI,SAAS,UAAU,EAAE,MAAM,CAAC;AACtD,CAAC,CAAC,CAAC,KAAK,OAAO,SAAS,SAAS,QAAQ,IAAI,kCAAkC,MAAM,CAAC,CAAC,CAC3F,CAAC,CAAC,KAAK,QAAQ,gBAAgB,gCAAgC,2BAA2B,CAAC;AAE3F,QAAQ,KAAK,UAAU,CAAC,CAAC,KACrB,QAAQ,gBAAgB,kCAAkC,GAC1D,QAAQ,gBAAgB,CACpB,oBAAoB,EAAE,kBAAkB,+BAA+B,CAAC,GACxE,GAAI,aAAa,CAAC,IAAI,IAAI,CAAC,CAC/B,CAAC,GACD,QAAQ,IAAI,EAAE,QAAQ,CAAC,GACvB,OAAO,QAAQ,aAAa,KAAK,GACjC,YAAY,OAChB"}

package/lib/cli/pull.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pull.d.ts","names":[],"sources":["../../src/cli/pull.ts"],"mappings":";;qBAWa;qBACA;wBA+BG,+BAA+B;wBAKzB,uBAAuB,qBAAqB,QAAQ;wBAcpD,oBAClB,QAAQ,oBACR,iBACA,SAAS,qBACT,8BACD"}
+{"version":3,"file":"pull.d.ts","names":[],"sources":["../../src/cli/pull.ts"],"mappings":";;qBAYa;qBACA;wBAoBG,+BAA+B;wBAKzB,uBAAuB,qBAAqB,QAAQ;wBAcpD,oBAClB,QAAQ,oBACR,iBACA,SAAS,qBACT,8BACD"}

package/lib/cli/pull.js

@@ -1,22 +1,16 @@
-import { pull } from "../meta/pull.js";
-import { formatGeneratedFile } from "./format.js";
-import { generateOntology } from "../generate/ontology.js";
+import { Effect, Predicate } from "effect";
+import { pull } from "@party-stack/ontology-backend/meta";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
-import { createJiti } from "jiti";
+import { formatGeneratedFile, generateOntology } from "@party-stack/ontology-spec/generate";
 import nextEnv from "@next/env";
+import { createJiti } from "jiti";
 //#region src/cli/pull.ts
 const { loadEnvConfig } = nextEnv;
 const ONTOLOGY_PULL_CONFIG_PATH = "src/ontology/config.ts";
 const ONTOLOGY_IR_PATH = "src/ontology/ontology.ts";
-function isRecord(value) {
-	return typeof value === "object" && value !== null;
-}
-function isOntologyPullSource(value) {
-	return isRecord(value) && typeof value.ontologyId === "string" && typeof value.createInstallation === "function" && typeof value.resolveConnection === "function";
-}
 function isOntologyPullConfig(value) {
-	return isRecord(value) && isOntologyPullSource(value.source) && Array.isArray(value.objectTypeNames) && value.objectTypeNames.every((entry) => typeof entry === "string") && Array.isArray(value.actionTypeNames) && value.actionTypeNames.every((entry) => typeof entry === "string") && (value.queryFunctionTypeNames === void 0 || Array.isArray(value.queryFunctionTypeNames) && value.queryFunctionTypeNames.every((entry) => typeof entry === "string"));
+	return Predicate.isObject(value) && Effect.isEffect(value.backend) && (value.transformPulledOntology === void 0 || typeof value.transformPulledOntology === "function") && Array.isArray(value.objectTypeNames) && value.objectTypeNames.every((entry) => typeof entry === "string") && Array.isArray(value.actionTypeNames) && value.actionTypeNames.every((entry) => typeof entry === "string") && (value.queryFunctionTypeNames === void 0 || Array.isArray(value.queryFunctionTypeNames) && value.queryFunctionTypeNames.every((entry) => typeof entry === "string"));
 }
 function discoverOntologyPullConfigPath(cwd) {
 	const configPath = resolve(cwd, ONTOLOGY_PULL_CONFIG_PATH);
@@ -28,27 +22,20 @@ async function loadOntologyPullConfig(configPath) {
 	if (!isOntologyPullConfig(config)) throw new Error(`Config file "${configPath}" must default export an OntologyPullConfig value.`);
 	return config;
 }
-async function writePulledOntology(config, outPath, context, ontologyImportPath = "@party-stack/ontology") {
-	const installation = await config.source.createInstallation(context);
-	try {
-		const connection = await config.source.resolveConnection(installation);
-		const liveOntology = await installation.openMetaOntology({
-			userId: connection.userId,
-			ontologyId: config.source.ontologyId
-		});
-		const pulledOntology = await pull(liveOntology, {
+async function writePulledOntology(config, outPath, context, ontologyImportPath = "@party-stack/ontology-spec") {
+	const ontology = await Effect.runPromise(Effect.scoped(Effect.gen(function* () {
+		const backend = yield* config.backend;
+		return yield* pull(backend, {
 			objectTypeNames: config.objectTypeNames,
 			actionTypeNames: config.actionTypeNames,
-			queryFunctionTypeNames: config.queryFunctionTypeNames ?? []
+			queryFunctionTypeNames: config.queryFunctionTypeNames ?? [],
+			transformPulledOntology: config.transformPulledOntology
 		});
-		const ontology = config.source.transformPulledOntology ? await config.source.transformPulledOntology(pulledOntology) : pulledOntology;
-		const output = generateOntology(ontology, { ontologyImportPath });
-		mkdirSync(dirname(outPath), { recursive: true });
-		const formatted = await formatGeneratedFile(outPath, output);
-		writeFileSync(outPath, formatted, "utf-8");
-	} finally {
-		await installation.cleanup();
-	}
+	})).pipe(Effect.provide(context.runtime)));
+	const output = generateOntology(ontology, { ontologyImportPath });
+	mkdirSync(dirname(outPath), { recursive: true });
+	const formatted = await formatGeneratedFile(outPath, output);
+	writeFileSync(outPath, formatted, "utf-8");
 }
 //#endregion
 export { ONTOLOGY_IR_PATH, ONTOLOGY_PULL_CONFIG_PATH, discoverOntologyPullConfigPath, loadOntologyPullConfig, writePulledOntology };

package/lib/cli/pull.js.map

@@ -1 +1 @@
-{"version":3,"file":"pull.js","names":[],"sources":["../../src/cli/pull.ts"],"sourcesContent":["import { existsSync, mkdirSync, writeFileSync } from \"node:fs\";\nimport { dirname, resolve } from \"node:path\";\nimport nextEnv from \"@next/env\";\nimport { createJiti } from \"jiti\";\nimport { generateOntology } from \"../generate/ontology.js\";\nimport { pull } from \"../meta/pull.js\";\nimport { formatGeneratedFile } from \"./format.js\";\nimport type { OntologyPullContext, OntologyPullSource, OntologyPullConfig } from \"../OntologyPullConfig.js\";\n\nconst { loadEnvConfig } = nextEnv;\n\nexport const ONTOLOGY_PULL_CONFIG_PATH = \"src/ontology/config.ts\";\nexport const ONTOLOGY_IR_PATH = \"src/ontology/ontology.ts\";\n\ntype ConfigModule = Record<string, unknown> & { default?: unknown };\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n    return typeof value === \"object\" && value !== null;\n}\n\nfunction isOntologyPullSource(value: unknown): value is OntologyPullSource {\n    return (\n        isRecord(value) &&\n        typeof value.ontologyId === \"string\" &&\n        typeof value.createInstallation === \"function\" &&\n        typeof value.resolveConnection === \"function\"\n    );\n}\n\nfunction isOntologyPullConfig(value: unknown): value is OntologyPullConfig {\n    return (\n        isRecord(value) &&\n        isOntologyPullSource(value.source) &&\n        Array.isArray(value.objectTypeNames) &&\n        value.objectTypeNames.every((entry) => typeof entry === \"string\") &&\n        Array.isArray(value.actionTypeNames) &&\n        value.actionTypeNames.every((entry) => typeof entry === \"string\") &&\n        (value.queryFunctionTypeNames === undefined ||\n            (Array.isArray(value.queryFunctionTypeNames) &&\n                value.queryFunctionTypeNames.every((entry) => typeof entry === \"string\")))\n    );\n}\n\nexport function discoverOntologyPullConfigPath(cwd: string): string | null {\n    const configPath = resolve(cwd, ONTOLOGY_PULL_CONFIG_PATH);\n    return existsSync(configPath) ? configPath : null;\n}\n\nexport async function loadOntologyPullConfig(configPath: string): Promise<OntologyPullConfig> {\n    loadEnvConfig(resolve(dirname(configPath), \"../..\"));\n\n    const jiti = createJiti(import.meta.url);\n    const configModule: ConfigModule = await jiti.import(configPath);\n    const config = configModule.default;\n\n    if (!isOntologyPullConfig(config)) {\n        throw new Error(`Config file \"${configPath}\" must default export an OntologyPullConfig value.`);\n    }\n\n    return config;\n}\n\nexport async function writePulledOntology(\n    config: OntologyPullConfig,\n    outPath: string,\n    context: OntologyPullContext,\n    ontologyImportPath = \"@party-stack/ontology\"\n): Promise<void> {\n    const installation = await config.source.createInstallation(context);\n\n    try {\n        const connection = await config.source.resolveConnection(installation);\n        const liveOntology = await installation.openMetaOntology({\n            userId: connection.userId,\n            ontologyId: config.source.ontologyId,\n        });\n        const pulledOntology = await pull(liveOntology, {\n            objectTypeNames: config.objectTypeNames,\n            actionTypeNames: config.actionTypeNames,\n            queryFunctionTypeNames: config.queryFunctionTypeNames ?? [],\n        });\n        const ontology = config.source.transformPulledOntology\n            ? await config.source.transformPulledOntology(pulledOntology)\n            : pulledOntology;\n        const output = generateOntology(ontology, { ontologyImportPath });\n\n        mkdirSync(dirname(outPath), { recursive: true });\n\n        const formatted = await formatGeneratedFile(outPath, output);\n\n        writeFileSync(outPath, formatted, \"utf-8\");\n    } finally {\n        await installation.cleanup();\n    }\n}\n"],"mappings":";;;;;;;;AASA,MAAM,EAAE,kBAAkB;AAE1B,MAAa,4BAA4B;AACzC,MAAa,mBAAmB;AAIhC,SAAS,SAAS,OAAkD;CAChE,OAAO,OAAO,UAAU,YAAY,UAAU;AAClD;AAEA,SAAS,qBAAqB,OAA6C;CACvE,OACI,SAAS,KAAK,KACd,OAAO,MAAM,eAAe,YAC5B,OAAO,MAAM,uBAAuB,cACpC,OAAO,MAAM,sBAAsB;AAE3C;AAEA,SAAS,qBAAqB,OAA6C;CACvE,OACI,SAAS,KAAK,KACd,qBAAqB,MAAM,MAAM,KACjC,MAAM,QAAQ,MAAM,eAAe,KACnC,MAAM,gBAAgB,OAAO,UAAU,OAAO,UAAU,QAAQ,KAChE,MAAM,QAAQ,MAAM,eAAe,KACnC,MAAM,gBAAgB,OAAO,UAAU,OAAO,UAAU,QAAQ,MAC/D,MAAM,2BAA2B,KAAA,KAC7B,MAAM,QAAQ,MAAM,sBAAsB,KACvC,MAAM,uBAAuB,OAAO,UAAU,OAAO,UAAU,QAAQ;AAEvF;AAEA,SAAgB,+BAA+B,KAA4B;CACvE,MAAM,aAAa,QAAQ,KAAK,yBAAyB;CACzD,OAAO,WAAW,UAAU,IAAI,aAAa;AACjD;AAEA,eAAsB,uBAAuB,YAAiD;CAC1F,cAAc,QAAQ,QAAQ,UAAU,GAAG,OAAO,CAAC;CAInD,MAAM,UAAS,MAFF,WAAW,YAAY,GACQ,CAAC,CAAC,OAAO,UAAU,EAAA,CACnC;CAE5B,IAAI,CAAC,qBAAqB,MAAM,GAC5B,MAAM,IAAI,MAAM,gBAAgB,WAAW,mDAAmD;CAGlG,OAAO;AACX;AAEA,eAAsB,oBAClB,QACA,SACA,SACA,qBAAqB,yBACR;CACb,MAAM,eAAe,MAAM,OAAO,OAAO,mBAAmB,OAAO;CAEnE,IAAI;EACA,MAAM,aAAa,MAAM,OAAO,OAAO,kBAAkB,YAAY;EACrE,MAAM,eAAe,MAAM,aAAa,iBAAiB;GACrD,QAAQ,WAAW;GACnB,YAAY,OAAO,OAAO;EAC9B,CAAC;EACD,MAAM,iBAAiB,MAAM,KAAK,cAAc;GAC5C,iBAAiB,OAAO;GACxB,iBAAiB,OAAO;GACxB,wBAAwB,OAAO,0BAA0B,CAAC;EAC9D,CAAC;EACD,MAAM,WAAW,OAAO,OAAO,0BACzB,MAAM,OAAO,OAAO,wBAAwB,cAAc,IAC1D;EACN,MAAM,SAAS,iBAAiB,UAAU,EAAE,mBAAmB,CAAC;EAEhE,UAAU,QAAQ,OAAO,GAAG,EAAE,WAAW,KAAK,CAAC;EAE/C,MAAM,YAAY,MAAM,oBAAoB,SAAS,MAAM;EAE3D,cAAc,SAAS,WAAW,OAAO;CAC7C,UAAU;EACN,MAAM,aAAa,QAAQ;CAC/B;AACJ"}
+{"version":3,"file":"pull.js","names":[],"sources":["../../src/cli/pull.ts"],"sourcesContent":["import { existsSync, mkdirSync, writeFileSync } from \"node:fs\";\nimport { dirname, resolve } from \"node:path\";\nimport nextEnv from \"@next/env\";\nimport { pull } from \"@party-stack/ontology-backend/meta\";\nimport { generateOntology } from \"@party-stack/ontology-spec/generate\";\nimport { formatGeneratedFile } from \"@party-stack/ontology-spec/generate\";\nimport { Effect, Predicate } from \"effect\";\nimport { createJiti } from \"jiti\";\nimport type { OntologyPullContext, OntologyPullConfig } from \"../OntologyPullConfig.js\";\n\nconst { loadEnvConfig } = nextEnv;\n\nexport const ONTOLOGY_PULL_CONFIG_PATH = \"src/ontology/config.ts\";\nexport const ONTOLOGY_IR_PATH = \"src/ontology/ontology.ts\";\n\ntype ConfigModule = Record<string, unknown> & { default?: unknown };\n\nfunction isOntologyPullConfig(value: unknown): value is OntologyPullConfig {\n    return (\n        Predicate.isObject(value) &&\n        Effect.isEffect(value.backend) &&\n        (value.transformPulledOntology === undefined ||\n            typeof value.transformPulledOntology === \"function\") &&\n        Array.isArray(value.objectTypeNames) &&\n        value.objectTypeNames.every((entry) => typeof entry === \"string\") &&\n        Array.isArray(value.actionTypeNames) &&\n        value.actionTypeNames.every((entry) => typeof entry === \"string\") &&\n        (value.queryFunctionTypeNames === undefined ||\n            (Array.isArray(value.queryFunctionTypeNames) &&\n                value.queryFunctionTypeNames.every((entry) => typeof entry === \"string\")))\n    );\n}\n\nexport function discoverOntologyPullConfigPath(cwd: string): string | null {\n    const configPath = resolve(cwd, ONTOLOGY_PULL_CONFIG_PATH);\n    return existsSync(configPath) ? configPath : null;\n}\n\nexport async function loadOntologyPullConfig(configPath: string): Promise<OntologyPullConfig> {\n    loadEnvConfig(resolve(dirname(configPath), \"../..\"));\n\n    const jiti = createJiti(import.meta.url);\n    const configModule: ConfigModule = await jiti.import(configPath);\n    const config = configModule.default;\n\n    if (!isOntologyPullConfig(config)) {\n        throw new Error(`Config file \"${configPath}\" must default export an OntologyPullConfig value.`);\n    }\n\n    return config;\n}\n\nexport async function writePulledOntology(\n    config: OntologyPullConfig,\n    outPath: string,\n    context: OntologyPullContext,\n    ontologyImportPath = \"@party-stack/ontology-spec\"\n): Promise<void> {\n    const ontology = await Effect.runPromise(\n        Effect.scoped(\n            Effect.gen(function* () {\n                const backend = yield* config.backend;\n                return yield* pull(backend, {\n                    objectTypeNames: config.objectTypeNames,\n                    actionTypeNames: config.actionTypeNames,\n                    queryFunctionTypeNames: config.queryFunctionTypeNames ?? [],\n                    transformPulledOntology: config.transformPulledOntology,\n                });\n            })\n        ).pipe(Effect.provide(context.runtime))\n    );\n    const output = generateOntology(ontology, { ontologyImportPath });\n\n    mkdirSync(dirname(outPath), { recursive: true });\n\n    const formatted = await formatGeneratedFile(outPath, output);\n\n    writeFileSync(outPath, formatted, \"utf-8\");\n}\n"],"mappings":";;;;;;;;AAUA,MAAM,EAAE,kBAAkB;AAE1B,MAAa,4BAA4B;AACzC,MAAa,mBAAmB;AAIhC,SAAS,qBAAqB,OAA6C;CACvE,OACI,UAAU,SAAS,KAAK,KACxB,OAAO,SAAS,MAAM,OAAO,MAC5B,MAAM,4BAA4B,KAAA,KAC/B,OAAO,MAAM,4BAA4B,eAC7C,MAAM,QAAQ,MAAM,eAAe,KACnC,MAAM,gBAAgB,OAAO,UAAU,OAAO,UAAU,QAAQ,KAChE,MAAM,QAAQ,MAAM,eAAe,KACnC,MAAM,gBAAgB,OAAO,UAAU,OAAO,UAAU,QAAQ,MAC/D,MAAM,2BAA2B,KAAA,KAC7B,MAAM,QAAQ,MAAM,sBAAsB,KACvC,MAAM,uBAAuB,OAAO,UAAU,OAAO,UAAU,QAAQ;AAEvF;AAEA,SAAgB,+BAA+B,KAA4B;CACvE,MAAM,aAAa,QAAQ,KAAK,yBAAyB;CACzD,OAAO,WAAW,UAAU,IAAI,aAAa;AACjD;AAEA,eAAsB,uBAAuB,YAAiD;CAC1F,cAAc,QAAQ,QAAQ,UAAU,GAAG,OAAO,CAAC;CAInD,MAAM,UAAS,MAFF,WAAW,YAAY,GACQ,CAAC,CAAC,OAAO,UAAU,EAAA,CACnC;CAE5B,IAAI,CAAC,qBAAqB,MAAM,GAC5B,MAAM,IAAI,MAAM,gBAAgB,WAAW,mDAAmD;CAGlG,OAAO;AACX;AAEA,eAAsB,oBAClB,QACA,SACA,SACA,qBAAqB,8BACR;CACb,MAAM,WAAW,MAAM,OAAO,WAC1B,OAAO,OACH,OAAO,IAAI,aAAa;EACpB,MAAM,UAAU,OAAO,OAAO;EAC9B,OAAO,OAAO,KAAK,SAAS;GACxB,iBAAiB,OAAO;GACxB,iBAAiB,OAAO;GACxB,wBAAwB,OAAO,0BAA0B,CAAC;GAC1D,yBAAyB,OAAO;EACpC,CAAC;CACL,CAAC,CACL,CAAC,CAAC,KAAK,OAAO,QAAQ,QAAQ,OAAO,CAAC,CAC1C;CACA,MAAM,SAAS,iBAAiB,UAAU,EAAE,mBAAmB,CAAC;CAEhE,UAAU,QAAQ,OAAO,GAAG,EAAE,WAAW,KAAK,CAAC;CAE/C,MAAM,YAAY,MAAM,oBAAoB,SAAS,MAAM;CAE3D,cAAc,SAAS,WAAW,OAAO;AAC7C"}

package/lib/client.d.ts

@@ -0,0 +1,11 @@
+import { BackendError } from "@party-stack/ontology-backend";
+import { Effect, Scope } from "effect";
+import { OntologyServerClient } from "@party-stack/ontology-server/rpc";
+//#region src/client.d.ts
+/** Open one shared transport at an application boundary. Selected views borrow it. */
+export declare function createOntologyClient(open: Effect.Effect<OntologyServerClient, BackendError, Scope.Scope>): Promise<{
+  ontology: (name?: string, options?: import("@party-stack/ontology-server/rpc").OntologyClientOptions) => Effect.Effect<import("@party-stack/ontology-server/rpc").OntologyClient, BackendError, Scope.Scope>;
+  cleanup: () => Promise<void>;
+}>;
+//#endregion
+//# sourceMappingURL=client.d.ts.map

package/lib/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","names":[],"sources":["../src/client.ts"],"mappings":";;;;;wBAKsB,qBAClB,MAAM,OAAO,OAAO,sBAAsB,cAAc,MAAM,SAAM"}

package/lib/client.js

@@ -0,0 +1,21 @@
+import { Effect, Exit, Scope } from "effect";
+//#region src/client.ts
+/** Open one shared transport at an application boundary. Selected views borrow it. */
+async function createOntologyClient(open) {
+	const scope = Effect.runSync(Scope.make());
+	try {
+		const client = await Effect.runPromise(Scope.provide(open, scope));
+		let closing;
+		return {
+			...client,
+			cleanup: () => closing ??= Effect.runPromise(Scope.close(scope, Exit.void))
+		};
+	} catch (cause) {
+		await Effect.runPromise(Scope.close(scope, Exit.fail(cause)));
+		throw cause;
+	}
+}
+//#endregion
+export { createOntologyClient };
+
+//# sourceMappingURL=client.js.map

package/lib/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","names":[],"sources":["../src/client.ts"],"sourcesContent":["import { Effect, Exit, Scope } from \"effect\";\nimport type { BackendError } from \"@party-stack/ontology-backend\";\nimport type { OntologyServerClient } from \"@party-stack/ontology-server/rpc\";\n\n/** Open one shared transport at an application boundary. Selected views borrow it. */\nexport async function createOntologyClient(\n    open: Effect.Effect<OntologyServerClient, BackendError, Scope.Scope>\n) {\n    const scope = Effect.runSync(Scope.make());\n    try {\n        const client = await Effect.runPromise(Scope.provide(open, scope));\n        let closing: Promise<void> | undefined;\n        return { ...client, cleanup: () => (closing ??= Effect.runPromise(Scope.close(scope, Exit.void))) };\n    } catch (cause) {\n        await Effect.runPromise(Scope.close(scope, Exit.fail(cause)));\n        throw cause;\n    }\n}\n"],"mappings":";;;AAKA,eAAsB,qBAClB,MACF;CACE,MAAM,QAAQ,OAAO,QAAQ,MAAM,KAAK,CAAC;CACzC,IAAI;EACA,MAAM,SAAS,MAAM,OAAO,WAAW,MAAM,QAAQ,MAAM,KAAK,CAAC;EACjE,IAAI;EACJ,OAAO;GAAE,GAAG;GAAQ,eAAgB,YAAY,OAAO,WAAW,MAAM,MAAM,OAAO,KAAK,IAAI,CAAC;EAAG;CACtG,SAAS,OAAO;EACZ,MAAM,OAAO,WAAW,MAAM,MAAM,OAAO,KAAK,KAAK,KAAK,CAAC,CAAC;EAC5D,MAAM;CACV;AACJ"}