@tanglemedia/svelte-starter-toolbelt 2.0.0-next.1 → 2.0.0-next.3

package/README.md

@@ -1,58 +1,63 @@
-# Svelte library
+# @tanglemedia/svelte-starter-toolbelt
 
-Everything you need to build a Svelte library, powered by [`sv`](https://npmjs.com/package/sv).
+Shared service, query, mutation, proxy, and utility helpers used across the Svelte Starter.
 
-Read more about creating a library [in the docs](https://svelte.dev/docs/kit/packaging).
+## Service providers
 
-## Creating a project
+`createServiceFactory` builds typed collection services on top of a provider:
 
-If you're seeing this, you've probably already done this step. Congrats!
+- `createDirectusServiceProvider` for Directus-backed collections
+- `createFetchServiceProvider` for generic REST APIs
+- `createFixtureServiceProvider` for local JSON fixtures served through core's `fixture` adapter
 
-```bash
-# create a new project in the current directory
-npx sv create
+### Fixture provider example
 
-# create a new project in my-app
-npx sv create my-app
-```
+```typescript
+import {
+  createFixtureServiceProvider,
+  createServiceFactory
+} from '@tanglemedia/svelte-starter-toolbelt';
+import configuredApp from '$boot';
 
-## Developing
+type User = {
+  id: number;
+  name: string;
+};
 
-Once you've created a project and installed dependencies with `npm install` (or `pnpm install` or `yarn`), start a development server:
+type Schema = {
+  users: User;
+};
 
-```bash
-npm run dev
+export const createService = createServiceFactory<Schema, typeof createFixtureServiceProvider>(
+  configuredApp,
+  createFixtureServiceProvider
+);
 
-# or start the server and open the app in a new browser tab
-npm run dev -- --open
+export const usersService = createService('users');
+export const { findUsers, findUsersById } = usersService;
 ```
 
-Everything inside `src/lib` is part of your library, everything inside `src/routes` can be used as a showcase or preview app.
-
-## Building
+`createFixtureServiceProvider` defaults `adapterKey` to `'fixture'`, so it works with this
+`api.yml` setup:
 
-To build your library:
+```yaml
+default: 'fixture'
 
-```bash
-npm run package
+adapters:
+  fixture:
+    adapter: fixture
+    configuration: {}
 ```
 
-To create a production version of your showcase app:
+If you need a different adapter key:
 
-```bash
-npm run build
+```typescript
+export const tenantUsersService = createService('users', {
+  adapterKey: 'tenant-fixture'
+});
 ```
 
-You can preview the production build with `npm run preview`.
-
-> To deploy your app, you may need to install an [adapter](https://svelte.dev/docs/kit/adapters) for your target environment.
-
-## Publishing
+## More docs
 
-Go into the `package.json` and give your package the desired name through the `"name"` option. Also consider adding a `"license"` field and point it to a `LICENSE` file which you can create from a template (one popular option is the [MIT license](https://opensource.org/license/mit/)).
-
-To publish your library to [npm](https://www.npmjs.com):
-
-```bash
-npm publish
-```
+- Package docs: `docs/packages/toolbelt.md`
+- Service-focused guide: `docs/packages/toolbelt-services.md`

package/dist/service/index.d.ts

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

package/dist/service/index.js

@@ -1,2 +1,4 @@
 export * from "./provider/create-directus-service.provider.js";
+export * from "./provider/create-fetch-service.provider.js";
+export * from "./provider/create-fixture-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/provider/create-fixture-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 BaseFixtureService<T extends AnyObject> extends ServiceAbstract<T> {
+}
+type FixtureServiceProviderOpt<T extends AnyObject> = {
+    serviceClass?: (base: ConfigurableServiceClass<T, BaseFixtureService<T>>) => ConfigurableServiceClass<T, BaseFixtureService<T>>;
+    adapterKey?: string;
+};
+export declare function createFixtureServiceProvider({ configureService }: ConfiguredApplication): <T extends AnyObject>(collection: string, opt?: Partial<ServiceAbstractOptions> & FixtureServiceProviderOpt<T>) => BaseFixtureService<T>;
+export {};

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

@@ -0,0 +1,18 @@
+import { ServiceAbstract } from '@tanglemedia/svelte-starter-core';
+export class BaseFixtureService extends ServiceAbstract {
+}
+export function createFixtureServiceProvider({ configureService }) {
+    const services = {};
+    return (collection, opt) => {
+        const k = JSON.stringify([collection, opt]);
+        if (services[k]) {
+            return services[k];
+        }
+        const Service = opt?.serviceClass ? opt.serviceClass(BaseFixtureService) : BaseFixtureService;
+        return (services[k] = configureService(Service, {
+            path: collection,
+            adapterKey: opt?.adapterKey ?? 'fixture',
+            ...(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/dist/utility/query-factory.d.ts

@@ -1,6 +1,10 @@
-import type { BaseMutationOpt, TMutationBase } from '../types/index.ts';
+import type { BaseMutationOpt, InfiniteQueryOpt, TMutationBase } from '../types/index.ts';
 import type { ApiPostQuery, ServiceAbstract } from '@tanglemedia/svelte-starter-core';
-import { type CreateFindInfiniteQueryOpt } from './query/create-find-infinite-query.svelte.ts';
+export type CreateFindInfiniteQueryOpt<T extends object> = {
+    collection: string;
+    service: ServiceAbstract<T>;
+    options?: InfiniteQueryOpt;
+};
 export type CreateMutationOpt<T extends TMutationBase> = {
     collection: string;
     service: ServiceAbstract<T>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanglemedia/svelte-starter-toolbelt",
-  "version": "2.0.0-next.1",
+  "version": "2.0.0-next.3",
   "files": [
     "src",
     "dist",
@@ -29,7 +29,7 @@
   },
   "peerDependencies": {
     "@directus/sdk": ">=17.0.0",
-    "@tanglemedia/svelte-starter-core": ">=4.0.0-next.0",
+    "@tanglemedia/svelte-starter-core": ">=4.0.0-next.1",
     "@tanstack/svelte-query": ">=6",
     "svelte": "^5.0.0"
   },
@@ -62,8 +62,9 @@
     "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-core": "4.0.0-next.1",
     "@tanglemedia/svelte-starter-types": "3.0.0-next.0"
   },
   "keywords": [

package/src/lib/service/index.ts

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

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

@@ -45,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/provider/create-fixture-service.provider.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, test, vi } from 'vitest';
+import type { ConfiguredApplication, ServiceAbstractOptions } from '@tanglemedia/svelte-starter-core';
+
+import {
+	BaseFixtureService,
+	createFixtureServiceProvider
+} from './create-fixture-service.provider';
+
+describe('createFixtureServiceProvider', () => {
+	test('returns a factory function', () => {
+		const app = {
+			configureService: vi.fn()
+		} as unknown as ConfiguredApplication;
+
+		const createService = createFixtureServiceProvider(app);
+
+		expect(typeof createService).toBe('function');
+	});
+
+	test('caches service instances for the same collection and options', () => {
+		const instance = { service: 'fixture' };
+		const app = {
+			configureService: vi.fn(() => instance)
+		} as unknown as ConfiguredApplication;
+		const createService = createFixtureServiceProvider(app);
+
+		const first = createService('users');
+		const second = createService('users');
+
+		expect(first).toBe(second);
+		expect(app.configureService).toHaveBeenCalledOnce();
+	});
+
+	test('defaults adapterKey to fixture', () => {
+		const configureService = vi.fn();
+		const app = {
+			configureService
+		} as unknown as ConfiguredApplication;
+		const createService = createFixtureServiceProvider(app);
+
+		createService('users');
+
+		expect(configureService).toHaveBeenCalledWith(
+			BaseFixtureService,
+			expect.objectContaining({
+				path: 'users',
+				adapterKey: 'fixture'
+			})
+		);
+	});
+
+	test('passes through a custom adapterKey when provided', () => {
+		const configureService = vi.fn();
+		const app = {
+			configureService
+		} as unknown as ConfiguredApplication;
+		const createService = createFixtureServiceProvider(app);
+
+		createService('users', {
+			adapterKey: 'tenant-fixture'
+		});
+
+		expect(configureService).toHaveBeenCalledWith(
+			BaseFixtureService,
+			expect.objectContaining({
+				adapterKey: 'tenant-fixture'
+			})
+		);
+	});
+
+	test('uses a custom serviceClass when provided', () => {
+		const configureService = vi.fn();
+		const app = {
+			configureService
+		} as unknown as ConfiguredApplication;
+		const createService = createFixtureServiceProvider(app);
+
+		class CustomFixtureService<T extends Record<string, unknown>> extends BaseFixtureService<T> {}
+
+		createService('users', {
+			serviceClass: () => CustomFixtureService,
+			throwError: false
+		} as Partial<ServiceAbstractOptions>);
+
+		expect(configureService).toHaveBeenCalledWith(
+			CustomFixtureService,
+			expect.objectContaining({
+				path: 'users',
+				adapterKey: 'fixture',
+				throwError: false
+			})
+		);
+	});
+});

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

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

package/src/lib/utility/query-factory.ts

@@ -1,16 +1,16 @@
 import type { BaseMutationOpt, InfiniteQueryOpt, TMutationBase } from '../types/index.ts';
 import type { ApiPostQuery, ServiceAbstract } from '@tanglemedia/svelte-starter-core';
 import { createInsertMutation } from './mutation/create-insert-mutation.ts';
-import { createFindInfiniteQuery, type CreateFindInfiniteQueryOpt } from './query/create-find-infinite-query.svelte.ts';
+import { createFindInfiniteQuery } from './query/create-find-infinite-query.svelte.ts';
 import { createFindOneQuery } from './query/create-find-one-query.svelte.ts';
 import { createFindQuery, getTotalCountQuery } from './query/create-find-query.svelte.ts';
 import { createBulkDeleteMutation, createDeleteMutation, createUpdateMutation } from './mutation';
 
-// export type CreateFindInfiniteQueryOpt<T extends object> = {
-// 	collection: string;
-// 	service: ServiceAbstract<T>;
-// 	options?: InfiniteQueryOpt;
-// };
+export type CreateFindInfiniteQueryOpt<T extends object> = {
+	collection: string;
+	service: ServiceAbstract<T>;
+	options?: InfiniteQueryOpt;
+};
 
 export type CreateMutationOpt<T extends TMutationBase> = {
 	collection: string;