@tanglemedia/svelte-starter-toolbelt 2.0.0-next.0 → 2.0.0-next.2

package/dist/service/index.d.ts

@@ -1,2 +1,3 @@
 export * from './provider/create-directus-service.provider.ts';
+export * from './provider/create-fetch-service.provider.ts';
 export * from './service.factory.ts';

package/dist/service/index.js

@@ -1,2 +1,3 @@
 export * from "./provider/create-directus-service.provider.js";
+export * from "./provider/create-fetch-service.provider.js";
 export * from "./service.factory.js";

package/dist/service/provider/create-directus-service.provider.d.ts

@@ -747,5 +747,6 @@ export declare class DirectusBaseService<T extends AnyObject> extends ServiceAbs
 type ServiceProviderOpt<T extends AnyObject> = {
     serviceClass?: (base: ConfigurableServiceClass<T>) => ConfigurableServiceClass<T, DirectusBaseService<T>>;
 };
+export declare function isDirectusService<T extends AnyObject>(service: ServiceAbstract<T>): service is DirectusBaseService<T>;
 export declare function createDirectusServiceProvider({ configureService }: ConfiguredApplication): <T extends AnyObject>(collection: string, opt?: Partial<ServiceAbstractOptions> & ServiceProviderOpt<T>) => DirectusBaseService<T>;
 export {};

package/dist/service/provider/create-directus-service.provider.js

@@ -17,6 +17,9 @@ export class DirectusBaseService extends ServiceAbstract {
     }
 }
 // const extender = (...parts: ConfigurableServiceClass[]) => parts.reduce((acc, ext) => ext(acc), DirectusBaseService);
+export function isDirectusService(service) {
+    return service instanceof DirectusBaseService;
+}
 export function createDirectusServiceProvider({ configureService }) {
     /**
      * Variable used for internal caching so that services with the same

package/dist/service/provider/create-fetch-service.provider.d.ts

@@ -0,0 +1,9 @@
+import { ServiceAbstract, type AnyObject, type ConfigurableServiceClass, type ConfiguredApplication, type ServiceAbstractOptions } from '@tanglemedia/svelte-starter-core';
+export declare class BaseService<T extends AnyObject> extends ServiceAbstract<T> {
+}
+type FetchServiceProviderOpt<T extends AnyObject> = {
+    serviceClass?: (base: ConfigurableServiceClass<T, BaseService<T>>) => ConfigurableServiceClass<T, BaseService<T>>;
+    adapterKey?: string;
+};
+export declare function createFetchServiceProvider({ configureService }: ConfiguredApplication): <T extends AnyObject>(collection: string, opt?: Partial<ServiceAbstractOptions> & FetchServiceProviderOpt<T>) => BaseService<T>;
+export {};

package/dist/service/provider/create-fetch-service.provider.js

@@ -0,0 +1,18 @@
+import { ServiceAbstract } from '@tanglemedia/svelte-starter-core';
+export class BaseService extends ServiceAbstract {
+}
+export function createFetchServiceProvider({ configureService }) {
+    const services = {};
+    return (collection, opt) => {
+        const k = JSON.stringify([collection, opt]);
+        if (services[k]) {
+            return services[k];
+        }
+        const Service = opt?.serviceClass ? opt.serviceClass(BaseService) : BaseService;
+        return (services[k] = configureService(Service, {
+            path: collection,
+            adapterKey: opt?.adapterKey ?? 'fetch',
+            ...(opt ?? {})
+        }));
+    };
+}

package/dist/service/service.factory.d.ts

@@ -1,5 +1,5 @@
 import type { AnyObject, ConfiguredApplication, ServiceAbstract, ServiceAbstractOptions } from "@tanglemedia/svelte-starter-core";
-import { DirectusBaseService } from "./provider/create-directus-service.provider";
+import { createDirectusServiceProvider } from "./provider/create-directus-service.provider";
 import { createApiMutations, createApiQueries } from "../utility/query-factory.ts";
 import type { CamelCase } from "../types/index.ts";
 import type { CreateFindOneFactory } from "../utility/query/create-find-one-query.svelte.ts";
@@ -28,7 +28,25 @@ type ServiceFactoryReturn<T extends AnyObject, P extends string, S extends Servi
     }>)>;
 };
 /**
- * Initial attempt to reduce the number of boiler plating done for directus services
+ * The shape of a provider creator — a function that accepts a configured app
+ * and returns a bound provider. This matches createDirectusServiceProvider,
+ * createFetchServiceProvider, or any developer-supplied custom provider.
  */
-export declare function createServiceFactory<Schema extends Record<string, AnyObject>>(app: ConfiguredApplication): <P extends string>(collection: P, opt?: Partial<ServiceAbstractOptions>) => ServiceFactoryReturn<Schema[P], P, DirectusBaseService<Schema[P]>>;
+export type ProviderCreator = (app: ConfiguredApplication) => <T extends AnyObject>(collection: string, opt?: Partial<ServiceAbstractOptions> & Record<string, unknown>) => ServiceAbstract<T>;
+/**
+ * Infers the concrete service instance type from a provider creator PC for a
+ * given row type T. Walks PC → ReturnType<PC> (bound provider) → infer R from
+ * its return → intersect with ServiceAbstract<T> to bind the concrete T slot.
+ *
+ * Examples:
+ *   ExtractService<typeof createDirectusServiceProvider, Product> → DirectusBaseService<Product>
+ *   ExtractService<typeof createFetchServiceProvider, Product>    → BaseService<Product>
+ */
+export type ExtractService<PC extends ProviderCreator, T extends AnyObject> = ReturnType<PC> extends <_U extends AnyObject>(collection: string, opt?: any) => infer R ? R extends ServiceAbstract<AnyObject> ? R & ServiceAbstract<T> : ServiceAbstract<T> : ServiceAbstract<T>;
+/**
+ * Creates a per-schema service factory. Pass a provider creator as the second
+ * argument to choose the adapter backing (Directus or fetch). Defaults to
+ * createDirectusServiceProvider for full backward compatibility.
+ */
+export declare function createServiceFactory<Schema extends Record<string, AnyObject>, PC extends ProviderCreator = typeof createDirectusServiceProvider>(app: ConfiguredApplication, providerCreator?: PC): <P extends string>(collection: P, opt?: Partial<ServiceAbstractOptions>) => ServiceFactoryReturn<Schema[P], P, ExtractService<PC, Schema[P]>>;
 export {};

package/dist/service/service.factory.js

@@ -1,35 +1,37 @@
-import { createDirectusServiceProvider, DirectusBaseService } from "./provider/create-directus-service.provider";
+import { createDirectusServiceProvider } from "./provider/create-directus-service.provider";
 import { createApiMutations, createApiQueries } from "../utility/query-factory.js";
 import camelCase from 'lodash.camelcase';
 /**
- * Initial attempt to reduce the number of boiler plating done for directus services
+ * Creates a per-schema service factory. Pass a provider creator as the second
+ * argument to choose the adapter backing (Directus or fetch). Defaults to
+ * createDirectusServiceProvider for full backward compatibility.
  */
-export function createServiceFactory(app) {
-    const serviceProvider = createDirectusServiceProvider(app);
-    // type K = keyof Schema;
-    // function factory<T extends AnyObject> (collection: Px, opt?: Partial<ServiceAbstractOptions>): ServiceFactoryReturn<T, Px, DirectusBaseService<T>>;
+export function createServiceFactory(app, providerCreator = createDirectusServiceProvider) {
+    // Cast to ReturnType<PC> so the generic call below is typed against the
+    // concrete bound provider rather than the loose ProviderCreator upper bound.
+    const serviceProvider = providerCreator(app);
     function factory(collection, opt) {
+        // Keep as ServiceAbstract<Schema[P]> inside the body to avoid the deferred
+        // conditional type (ExtractService) distributing to a union, which would
+        // prevent passing service to createApiMutations. The ExtractService cast
+        // is applied only on the final return object.
         const service = serviceProvider(collection, opt);
-        // console.log(`FACTORY ${collection}`, service)
         const createQuries = () => createApiQueries({
             collection,
             service
         });
         const createMutations = () => createApiMutations({
             collection,
-            service
+            // service is ServiceAbstract<Schema[P]>; cast to satisfy the id constraint
+            // required by createApiMutations. Safe: every concrete service impl handles
+            // id-bearing entities at runtime.
+            service: service
         });
-        // todo: Do the same for mutations
         const [find, findOne, findInfinite] = createQuries();
         const [createOne, updateOne, deleteOne] = createMutations();
         const k1 = camelCase(`find_${collection}`);
         const k2 = camelCase(`find_${collection}_by_id`);
         const k3 = camelCase(`find_${collection}_infinite`);
-        // const queries = {
-        //   [k1]: find,
-        //   [k2]: findOne,
-        //   [k3]: findInfinite,
-        // };
         const m1 = camelCase(`create_${collection}`);
         const m2 = camelCase(`update_${collection}`);
         const m3 = camelCase(`delete_${collection}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanglemedia/svelte-starter-toolbelt",
-  "version": "2.0.0-next.0",
+  "version": "2.0.0-next.2",
   "files": [
     "src",
     "dist",
@@ -10,17 +10,21 @@
   "sideEffects": [
     "**/*.css"
   ],
-  "svelte": "./src/index.ts",
-  "types": "./src/index.ts",
+  "module": "./dist/index.d.ts",
+  "svelte": "./dist/index.js",
   "type": "module",
   "exports": {
     ".": {
-      "types": "./src/index.ts",
-      "svelte": "./src/index.ts"
+      "types": "./dist/index.d.ts",
+      "svelte": "./dist/index.js",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     },
     "./server": {
-      "types": "./src/lib/server/index.ts",
-      "svelte": "./src/lib/server/index.ts"
+      "types": "./dist/server/index.d.ts",
+      "svelte": "./dist/server/index.js",
+      "import": "./dist/server/index.js",
+      "default": "./dist/server/index.js"
     }
   },
   "peerDependencies": {
@@ -58,9 +62,10 @@
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.54.0",
     "vite": "^8.0.8",
+    "msw": "^2.12.7",
     "vitest": "^4.1.4",
-    "@tanglemedia/svelte-starter-core": "4.0.0-next.0",
-    "@tanglemedia/svelte-starter-types": "3.0.0-next.0"
+    "@tanglemedia/svelte-starter-types": "3.0.0-next.0",
+    "@tanglemedia/svelte-starter-core": "4.0.0-next.0"
   },
   "keywords": [
     "svelte"

package/src/lib/service/index.ts

@@ -1,2 +1,3 @@
 export * from './provider/create-directus-service.provider.ts';
-export * from './service.factory.ts';
+export * from './provider/create-fetch-service.provider.ts';
+export * from './service.factory.ts';

package/src/lib/service/provider/create-directus-service.provider.ts

@@ -1,19 +1,17 @@
 import {
-	readMe,
-	type AuthenticationClient,
-	type DirectusClient,
-	type RestClient,
-	type RestCommand
+  readMe,
+  type AuthenticationClient,
+  type DirectusClient,
+  type RestClient,
+  type RestCommand
 } from '@directus/sdk';
 import {
-	ServiceAbstract,
-	type ServiceAdapterAbstract,
-	type AnyObject,
-	type ApiAdapterHandle,
-	type ConfigurableServiceClass,
-	type ConfiguredApplication,
-	type HandleEvent,
-	type ServiceAbstractOptions
+  ServiceAbstract,
+  type AnyObject,
+  type ConfigurableServiceClass,
+  type ConfiguredApplication,
+  type HandleEvent,
+  type ServiceAbstractOptions
 } from '@tanglemedia/svelte-starter-core';
 export class DirectusBaseService<T extends AnyObject> extends ServiceAbstract<T> {
 	public getDirectus() {
@@ -47,6 +45,12 @@ type ServiceProviderOpt<T extends AnyObject> = {
 
 // const extender = (...parts: ConfigurableServiceClass[]) => parts.reduce((acc, ext) => ext(acc), DirectusBaseService);
 
+export function isDirectusService<T extends AnyObject>(
+	service: ServiceAbstract<T>
+): service is DirectusBaseService<T> {
+	return service instanceof DirectusBaseService;
+}
+
 export function createDirectusServiceProvider({ configureService }: ConfiguredApplication) {
 
 	/**

package/src/lib/service/provider/create-fetch-service.provider.ts

@@ -0,0 +1,37 @@
+import {
+	ServiceAbstract,
+	type AnyObject,
+	type ConfigurableServiceClass,
+	type ConfiguredApplication,
+	type ServiceAbstractOptions
+} from '@tanglemedia/svelte-starter-core';
+
+export class BaseService<T extends AnyObject> extends ServiceAbstract<T> {}
+
+type FetchServiceProviderOpt<T extends AnyObject> = {
+	serviceClass?: (base: ConfigurableServiceClass<T, BaseService<T>>) => ConfigurableServiceClass<T, BaseService<T>>;
+	adapterKey?: string;
+};
+
+export function createFetchServiceProvider({ configureService }: ConfiguredApplication) {
+	const services: Record<string, unknown> = {};
+
+	return <T extends AnyObject>(
+		collection: string,
+		opt?: Partial<ServiceAbstractOptions> & FetchServiceProviderOpt<T>
+	): BaseService<T> => {
+		const k = JSON.stringify([collection, opt]);
+
+		if (services[k]) {
+			return services[k] as BaseService<T>;
+		}
+
+		const Service = opt?.serviceClass ? opt.serviceClass(BaseService) : BaseService<T>;
+
+		return (services[k] = configureService<T, BaseService<T>>(Service, {
+			path: collection,
+			adapterKey: opt?.adapterKey ?? 'fetch',
+			...(opt ?? {})
+		})) as BaseService<T>;
+	};
+}

package/src/lib/service/service.factory.test.ts

@@ -0,0 +1,284 @@
+import { setupServer } from 'msw/node';
+import { http, HttpResponse } from 'msw';
+import { afterAll, afterEach, beforeAll, describe, expect, test, vi } from 'vitest';
+import { ApiAdapterProvider } from '@tanglemedia/svelte-starter-core';
+import type { AnyObject, ConfiguredApplication, ServiceAbstractOptions } from '@tanglemedia/svelte-starter-core';
+import { createServiceFactory } from './service.factory';
+import { createDirectusServiceProvider, DirectusBaseService, isDirectusService } from './provider/create-directus-service.provider';
+import { BaseService, createFetchServiceProvider } from './provider/create-fetch-service.provider';
+
+vi.mock('$env/dynamic/public', () => ({ env: {} }));
+
+// ---------------------------------------------------------------------------
+// Mock data
+// ---------------------------------------------------------------------------
+
+type Product = { id: number; name: string; price: number };
+type Order = { id: number; productId: number; quantity: number };
+
+const products: Product[] = [
+	{ id: 1, name: 'Widget A', price: 9.99 },
+	{ id: 2, name: 'Widget B', price: 19.99 }
+];
+
+const orders: Order[] = [
+	{ id: 1, productId: 1, quantity: 2 },
+	{ id: 2, productId: 2, quantity: 1 }
+];
+
+// ---------------------------------------------------------------------------
+// MSW server
+// ---------------------------------------------------------------------------
+
+const BASE = 'https://api.test.local/api';
+
+const handlers = [
+	http.get(`${BASE}/product`, () => HttpResponse.json({ data: products })),
+	http.get(`${BASE}/product/1`, () => HttpResponse.json({ data: products[0] })),
+	http.get(`${BASE}/product/99`, () => HttpResponse.json({}, { status: 404 })),
+	http.post(`${BASE}/product`, async ({ request }) => {
+		const body = (await request.json()) as Omit<Product, 'id'>;
+		const created: Product = { id: products.length + 1, ...body };
+		products.push(created);
+		return HttpResponse.json({ data: created });
+	}),
+	http.patch(`${BASE}/product/1`, async ({ request }) => {
+		const body = (await request.json()) as Partial<Product>;
+		const updated = { ...products[0], ...body };
+		products[0] = updated;
+		return HttpResponse.json({ data: updated });
+	}),
+	http.delete(`${BASE}/product/1`, () => HttpResponse.json({ data: { id: 1 } })),
+
+	http.get(`${BASE}/order`, () => HttpResponse.json({ data: orders }))
+];
+
+const server = setupServer(...handlers);
+
+beforeAll(() => server.listen({ onUnhandledRequest: 'error' }));
+afterAll(() => server.close());
+afterEach(() => server.resetHandlers());
+
+// ---------------------------------------------------------------------------
+// Minimal ConfiguredApplication backed by the real fetch adapter
+// ---------------------------------------------------------------------------
+
+type Schema = {
+	product: Product;
+	order: Order;
+};
+
+const fetchConfig = {
+	api: {
+		default: 'fetch',
+		adapters: {
+			fetch: {
+				baseUrl: 'https://api.test.local',
+				configuration: { pathPrefix: '/api' }
+			}
+		}
+	}
+};
+
+// Build a minimal ConfiguredApplication that uses the real ApiAdapterProvider
+// with a static in-memory config — mirrors the pattern from core service tests.
+const mockConfigStore = {
+	config: (key: string): unknown => {
+		const cfg: Record<string, unknown> = {
+			'api.default': fetchConfig.api.default,
+			'api.adapters.fetch': fetchConfig.api.adapters.fetch
+		};
+		return cfg[key];
+	}
+};
+
+const adapterProvider = new ApiAdapterProvider(async () => mockConfigStore as any);
+
+const mockApp: ConfiguredApplication = {
+	configureService: <T extends AnyObject, S>(
+		ServiceClass: new (p: typeof adapterProvider, o: ServiceAbstractOptions) => S,
+		opt: ServiceAbstractOptions
+	) => new ServiceClass(adapterProvider, opt) as S
+} as unknown as ConfiguredApplication;
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('createServiceFactory — structure', () => {
+	test('factory function is returned', () => {
+		const createService = createServiceFactory<Schema, typeof createFetchServiceProvider>(mockApp, createFetchServiceProvider);
+		expect(typeof createService).toBe('function');
+	});
+
+	test('factory generates camelCase query method names for a collection', () => {
+		const createService = createServiceFactory<Schema, typeof createFetchServiceProvider>(mockApp, createFetchServiceProvider);
+		const productService = createService('product');
+
+		expect(typeof productService.findProduct).toBe('function');
+		expect(typeof productService.findProductById).toBe('function');
+		expect(typeof productService.findProductInfinite).toBe('function');
+	});
+
+	test('factory generates camelCase mutation method names for a collection', () => {
+		const createService = createServiceFactory<Schema, typeof createFetchServiceProvider>(mockApp, createFetchServiceProvider);
+		const productService = createService('product');
+
+		expect(typeof productService.createProduct).toBe('function');
+		expect(typeof productService.updateProduct).toBe('function');
+		expect(typeof productService.deleteProduct).toBe('function');
+	});
+
+	test('factory exposes createQuries and createMutations helpers', () => {
+		const createService = createServiceFactory<Schema, typeof createFetchServiceProvider>(mockApp, createFetchServiceProvider);
+		const productService = createService('product');
+
+		expect(typeof productService.createQuries).toBe('function');
+		expect(typeof productService.createMutations).toBe('function');
+	});
+
+	test('method names are scoped to the collection — order vs product', () => {
+		const createService = createServiceFactory<Schema, typeof createFetchServiceProvider>(mockApp, createFetchServiceProvider);
+		const orderService = createService('order');
+
+		expect(typeof orderService.findOrder).toBe('function');
+		expect(typeof orderService.findOrderById).toBe('function');
+		expect(typeof orderService.createOrder).toBe('function');
+
+		// order factory should NOT have product methods
+		expect((orderService as any).findProduct).toBeUndefined();
+	});
+
+	test('each call to factory returns a fresh service object', () => {
+		const createService = createServiceFactory<Schema, typeof createFetchServiceProvider>(mockApp, createFetchServiceProvider);
+		const a = createService('product');
+		const b = createService('order');
+		expect(a).not.toBe(b);
+	});
+});
+
+describe('createServiceFactory — service class types', () => {
+	test('fetch provider produces a BaseService instance', () => {
+		const createService = createServiceFactory<Schema, typeof createFetchServiceProvider>(mockApp, createFetchServiceProvider);
+		const { service } = createService('product');
+
+		expect(service).toBeInstanceOf(BaseService);
+	});
+
+	test('fetch provider service is NOT a DirectusBaseService', () => {
+		const createService = createServiceFactory<Schema, typeof createFetchServiceProvider>(mockApp, createFetchServiceProvider);
+		const { service } = createService('product');
+
+		expect(service).not.toBeInstanceOf(DirectusBaseService);
+	});
+
+	test('directus provider produces a DirectusBaseService instance', () => {
+		const createService = createServiceFactory<Schema>(mockApp, createDirectusServiceProvider);
+		const { service } = createService('product');
+
+		expect(service).toBeInstanceOf(DirectusBaseService);
+	});
+
+	test('default (no second arg) produces a DirectusBaseService instance', () => {
+		const createService = createServiceFactory<Schema>(mockApp);
+		const { service } = createService('product');
+
+		expect(service).toBeInstanceOf(DirectusBaseService);
+	});
+});
+
+describe('isDirectusService guard', () => {
+	test('returns true for DirectusBaseService', () => {
+		const createService = createServiceFactory<Schema>(mockApp, createDirectusServiceProvider);
+		const { service } = createService('product');
+
+		expect(isDirectusService(service)).toBe(true);
+	});
+
+	test('returns false for BaseService', () => {
+		const createService = createServiceFactory<Schema, typeof createFetchServiceProvider>(mockApp, createFetchServiceProvider);
+		const { service } = createService('product');
+
+		expect(isDirectusService(service)).toBe(false);
+	});
+
+	test('guard narrows type — getDirectus is accessible after guard', () => {
+		const createService = createServiceFactory<Schema>(mockApp, createDirectusServiceProvider);
+		const { service } = createService('product');
+
+		if (isDirectusService(service)) {
+			// TypeScript should see service as DirectusBaseService here
+			expect(typeof service.getDirectus).toBe('function');
+		} else {
+			throw new Error('Expected service to be a DirectusBaseService');
+		}
+	});
+});
+
+describe('createServiceFactory — fetch provider HTTP calls', () => {
+	test('service.find() returns all products', async () => {
+		const createService = createServiceFactory<Schema, typeof createFetchServiceProvider>(mockApp, createFetchServiceProvider);
+		const { service } = createService('product');
+
+		const { data } = await service.find({});
+
+		expect(data).toHaveLength(products.length);
+		expect(data[0]).toMatchObject({ name: 'Widget A' });
+	});
+
+	test('service.findOne() returns a single product by id', async () => {
+		const createService = createServiceFactory<Schema, typeof createFetchServiceProvider>(mockApp, createFetchServiceProvider);
+		const { service } = createService('product');
+
+		const { data } = await service.findOne(1);
+
+		expect(data).toMatchObject({ id: 1, name: 'Widget A' });
+	});
+
+	test('service.create() posts a new product and returns it', async () => {
+		const createService = createServiceFactory<Schema, typeof createFetchServiceProvider>(mockApp, createFetchServiceProvider);
+		const { service } = createService('product');
+
+		const { data } = await service.create({ name: 'Widget C', price: 29.99 });
+
+		expect(data).toMatchObject({ name: 'Widget C', price: 29.99 });
+		expect(data).toHaveProperty('id');
+	});
+
+	test('service.update() patches an existing product', async () => {
+		const createService = createServiceFactory<Schema, typeof createFetchServiceProvider>(mockApp, createFetchServiceProvider);
+		const { service } = createService('product');
+
+		const { data } = await service.update(1, { name: 'Widget A — Updated' });
+
+		expect(data).toMatchObject({ id: 1, name: 'Widget A — Updated' });
+	});
+
+	test('service.delete() removes a product', async () => {
+		const createService = createServiceFactory<Schema, typeof createFetchServiceProvider>(mockApp, createFetchServiceProvider);
+		const { service } = createService('product');
+
+		const { data } = await service.delete(1);
+
+		expect(data).toMatchObject({ id: 1 });
+	});
+
+	test('the same service instance is reused for identical collection + options', () => {
+		const createService = createServiceFactory<Schema, typeof createFetchServiceProvider>(mockApp, createFetchServiceProvider);
+		const a = createService('product');
+		const b = createService('product');
+
+		// createFetchServiceProvider caches by [collection, opt] key
+		expect(a.service).toBe(b.service);
+	});
+
+	test('order service can independently fetch orders', async () => {
+		const createService = createServiceFactory<Schema, typeof createFetchServiceProvider>(mockApp, createFetchServiceProvider);
+		const { service } = createService('order');
+
+		const { data } = await service.find({});
+
+		expect(data).toHaveLength(orders.length);
+		expect(data[0]).toMatchObject({ productId: 1 });
+	});
+});

package/src/lib/service/service.factory.ts

@@ -1,5 +1,5 @@
 import type { AnyObject, ConfiguredApplication, ServiceAbstract, ServiceAbstractOptions } from "@tanglemedia/svelte-starter-core";
-import { createDirectusServiceProvider, DirectusBaseService } from "./provider/create-directus-service.provider";
+import { createDirectusServiceProvider } from "./provider/create-directus-service.provider";
 import { createApiMutations, createApiQueries } from "../utility/query-factory.ts";
 import camelCase from 'lodash.camelcase';
 import type { CamelCase } from "../types/index.ts";
@@ -24,7 +24,6 @@ type MutationFactories<T extends AnyObject, P extends string> = {
 } & {
   [k in CamelCase<`delete_${P}`>]: CreateDeleteMutationFactory<any>;
 }
-// type QueryFactories<P extends string> = Record<CamelCase<`find_${P}`>, any>;
 
 type ServiceFactoryReturn<
   T extends AnyObject,
@@ -37,18 +36,62 @@ type ServiceFactoryReturn<
 };
 
 /**
- * Initial attempt to reduce the number of boiler plating done for directus services
+ * The shape of a provider creator — a function that accepts a configured app
+ * and returns a bound provider. This matches createDirectusServiceProvider,
+ * createFetchServiceProvider, or any developer-supplied custom provider.
  */
-export function createServiceFactory<Schema extends Record<string, AnyObject>>(app: ConfiguredApplication) {
-  const serviceProvider = createDirectusServiceProvider(app);
+export type ProviderCreator = (
+  app: ConfiguredApplication,
+) => <T extends AnyObject>(
+  collection: string,
+  opt?: Partial<ServiceAbstractOptions> & Record<string, unknown>,
+) => ServiceAbstract<T>;
 
-  // type K = keyof Schema;
+/**
+ * Infers the concrete service instance type from a provider creator PC for a
+ * given row type T. Walks PC → ReturnType<PC> (bound provider) → infer R from
+ * its return → intersect with ServiceAbstract<T> to bind the concrete T slot.
+ *
+ * Examples:
+ *   ExtractService<typeof createDirectusServiceProvider, Product> → DirectusBaseService<Product>
+ *   ExtractService<typeof createFetchServiceProvider, Product>    → BaseService<Product>
+ */
+export type ExtractService<PC extends ProviderCreator, T extends AnyObject> =
+  ReturnType<PC> extends <_U extends AnyObject>(
+    collection: string,
+    opt?: any,
+  ) => infer R
+    ? R extends ServiceAbstract<AnyObject>
+      ? R & ServiceAbstract<T>
+      : ServiceAbstract<T>
+    : ServiceAbstract<T>;
 
-  // function factory<T extends AnyObject> (collection: Px, opt?: Partial<ServiceAbstractOptions>): ServiceFactoryReturn<T, Px, DirectusBaseService<T>>;
-  function factory<P extends string>(collection: P, opt?: Partial<ServiceAbstractOptions>): ServiceFactoryReturn<Schema[P], P, DirectusBaseService<Schema[P]>> {
-    const service = serviceProvider<Schema[P]>(collection as string, opt);
+/**
+ * Creates a per-schema service factory. Pass a provider creator as the second
+ * argument to choose the adapter backing (Directus or fetch). Defaults to
+ * createDirectusServiceProvider for full backward compatibility.
+ */
+export function createServiceFactory<
+  Schema extends Record<string, AnyObject>,
+  PC extends ProviderCreator = typeof createDirectusServiceProvider,
+>(
+  app: ConfiguredApplication,
+  providerCreator: PC = createDirectusServiceProvider as unknown as PC,
+) {
+  // Cast to ReturnType<PC> so the generic call below is typed against the
+  // concrete bound provider rather than the loose ProviderCreator upper bound.
+  const serviceProvider = providerCreator(app) as ReturnType<PC>;
+
+  function factory<P extends string>(
+    collection: P,
+    opt?: Partial<ServiceAbstractOptions>,
+  ): ServiceFactoryReturn<Schema[P], P, ExtractService<PC, Schema[P]>> {
+    // Keep as ServiceAbstract<Schema[P]> inside the body to avoid the deferred
+    // conditional type (ExtractService) distributing to a union, which would
+    // prevent passing service to createApiMutations. The ExtractService cast
+    // is applied only on the final return object.
+    const service = serviceProvider<Schema[P]>(collection, opt);
 
-    // console.log(`FACTORY ${collection}`, service)
     const createQuries = () => createApiQueries<Schema[P]>({
       collection,
       service
@@ -56,21 +99,18 @@ export function createServiceFactory<Schema extends Record<string, AnyObject>>(a
 
     const createMutations = () => createApiMutations<Schema[P] & { id: string | number; }>({
       collection,
-      service
+      // service is ServiceAbstract<Schema[P]>; cast to satisfy the id constraint
+      // required by createApiMutations. Safe: every concrete service impl handles
+      // id-bearing entities at runtime.
+      service: service as ServiceAbstract<Schema[P] & { id: string | number }>
     });
 
-    // todo: Do the same for mutations
     const [find, findOne, findInfinite] = createQuries();
     const [createOne, updateOne, deleteOne] = createMutations();
 
-    const k1: CamelCase<`find_${P}`> = camelCase(`find_${collection}`) as CamelCase<`find_${P}`>
-    const k2: CamelCase<`find_${P}_by_id`> = camelCase(`find_${collection}_by_id`) as CamelCase<`find_${P}_by_id`>
-    const k3: CamelCase<`find_${P}_infinite`> = camelCase(`find_${collection}_infinite`) as CamelCase<`find_${P}_infinite`>
-    // const queries = {
-    //   [k1]: find,
-    //   [k2]: findOne,
-    //   [k3]: findInfinite,
-    // };
+    const k1: CamelCase<`find_${P}`> = camelCase(`find_${collection}`) as CamelCase<`find_${P}`>;
+    const k2: CamelCase<`find_${P}_by_id`> = camelCase(`find_${collection}_by_id`) as CamelCase<`find_${P}_by_id`>;
+    const k3: CamelCase<`find_${P}_infinite`> = camelCase(`find_${collection}_infinite`) as CamelCase<`find_${P}_infinite`>;
 
     const m1: CamelCase<`create_${P}`> = camelCase(`create_${collection}`) as CamelCase<`create_${P}`>;
     const m2: CamelCase<`update_${P}`> = camelCase(`update_${collection}`) as CamelCase<`update_${P}`>;
@@ -86,8 +126,8 @@ export function createServiceFactory<Schema extends Record<string, AnyObject>>(a
       [m1]: createOne,
       [m2]: updateOne,
       [m3]: deleteOne,
-    } as ServiceFactoryReturn<Schema[P], P, DirectusBaseService<Schema[P]>>;
+    } as ServiceFactoryReturn<Schema[P], P, ExtractService<PC, Schema[P]>>;
   }
 
   return factory;
-}
+}