nucleus-core-ts 0.9.866 → 0.9.867

package/dist/fe/components/IntegrationsPage/components/ConnectionTest.js

@@ -32,6 +32,13 @@ export function ConnectionTest({ actions, source, loading = false }) {
    * the record object is replaced but its id is not, so this never re-ran and a
    * green badge sat under an address that had never been called. Everything the
    * test actually depends on is in the key.
+   *
+   * A stored CREDENTIAL is such a setting, and it was the one left out. Clearing
+   * a token left the green verdict standing for a connection that would now be
+   * refused; the mirror image costs more of an afternoon — a red "Not reachable"
+   * from a 401 stayed up after the right password was saved, reading as "the
+   * password did not help". The masked hints are what move when a credential
+   * does, so they are what this watches.
    */ useEffect(()=>{
         clear();
     }, [
@@ -39,7 +46,10 @@ export function ConnectionTest({ actions, source, loading = false }) {
         source?.baseUrl,
         source?.authType,
         source?.tokenUrl,
-        source?.tlsVerify
+        source?.tlsVerify,
+        source?.authTokenHint,
+        source?.oauthClientSecretHint,
+        source?.oauthPasswordHint
     ]);
     const handleTest = ()=>{
         if (!source) return;

package/dist/fe/components/IntegrationsPage/components/EndpointSample.js

@@ -69,6 +69,30 @@ export function EndpointSample({ endpoint, actions }) {
         actions.sampleEndpoint(requestedFor, params.length > 0 ? values : undefined).then((result)=>{
             if (settleElsewhere(mine, requestedFor)) return;
             store.setSample(result, requestedFor);
+            /**
+         * The ROW learns it has been tried, not just this card.
+         *
+         * The step strip counts "tried" off `endpoints[].sampleResponse`,
+         * because whether a call has ever been run is a fact about the call and
+         * not about whichever screen is open. The server stores it there. This
+         * panel never did, so a connection whose calls had all been sampled
+         * went on announcing "7 call(s), 0 tried" — seen exactly that way on a
+         * customer's live connection, where it read as "nobody has ever tried
+         * these", which was not true.
+         *
+         * Only a sample that actually returned records counts, which is the
+         * same rule the strip applies.
+         */ if (result.ok && result.recordCount > 0) {
+                const row = store.endpoints.find((candidate)=>candidate.id === requestedFor);
+                if (row) {
+                    store.upsertEndpoint({
+                        ...row,
+                        sampleResponse: {
+                            records: result.sample
+                        }
+                    });
+                }
+            }
             if (!result.ok && result.error) store.setError(result.error);
         }).catch((error)=>{
             if (settleElsewhere(mine, requestedFor)) return;

package/dist/fe/components/IntegrationsPage/components/EndpointsTab.js

@@ -56,9 +56,22 @@ export function EndpointsTab({ actions }) {
         // selecting an id the list has not fetched yet made the whole editor
         // collapse to "pick one" — with the form still half-filled a moment ago.
         store.upsertEndpoint(saved);
-        // Re-selecting drops the old sample: it described the call as it was
-        // configured a moment ago, and the mapping would be built from it.
         store.selectEndpoint(saved.id);
+        /**
+     * The sample described the call as it was BEFORE this save.
+     *
+     * Re-selecting was supposed to drop it, and does not: `selectEndpoint`
+     * returns early when the id has not changed, which on a save it never has —
+     * it is the guard that stops re-choosing the open call from throwing away a
+     * sample somebody just paid a real request for. Correct there, and the
+     * reason nothing was cleared here.
+     *
+     * So the sample sat under an edited call: change `responseRootPath` from
+     * empty to `data`, save, and the card still reports "Status 200, 0 records"
+     * with the old body keys — and the mapping's field list is built from those
+     * keys. The answer on screen belonged to a request that is no longer the one
+     * configured.
+     */ store.setSample(null, null);
         setReloadToken((token)=>token + 1);
     };
     const handleDeleted = (deletedId)=>{

package/dist/fe/components/IntegrationsPage/store/index.js

@@ -93,6 +93,25 @@ export const { useStore: useIntegrationsStore } = createStore(initial, {
                     store.endpointsTotal = Math.max(0, store.endpointsTotal - 1);
                     store.endpoints = kept;
                 }
+                /**
+       * A mapping cannot outlive the call it reads from.
+       *
+       * The server deletes them — the foreign key cascades — and this list did
+       * not, so the step strip went on counting mappings that no longer existed
+       * and the IMPORT step stayed unlocked by them. Pressing it landed on an
+       * import whose mapping the server had already removed.
+       *
+       * Filtered here rather than at the call site because the store is what
+       * every one of those readings comes from; a caller that forgot would put
+       * the same ghost back.
+       */ const survivors = store.mappings.filter((mapping)=>mapping.endpointId !== id);
+                if (survivors.length !== store.mappings.length) {
+                    store.mappingsTotal = Math.max(0, store.mappingsTotal - (store.mappings.length - survivors.length));
+                    store.mappings = survivors;
+                    if (store.selectedMappingId && !survivors.some((m)=>m.id === store.selectedMappingId)) {
+                        store.selectedMappingId = null;
+                    }
+                }
             }),
     setEndpointsSearch: (store)=>(search)=>batch(()=>{
                 store.endpointsSearch = search;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "nucleus-core-ts",
-	"version": "0.9.866",
+	"version": "0.9.867",
 	"description": "Production-ready, enterprise-grade TypeScript framework for building multi-tenant APIs",
 	"author": "Hidayet Can Özcan <hidayetcan@gmail.com>",
 	"license": "SEE LICENSE IN LICENSE",

package/scripts/build.ts

@@ -113,8 +113,18 @@ async function transpileClientModules() {
 
       log.info(`  Transpiling directory: ${srcDir}`)
 
-      // Use swc to transpile - output to dist, swc will preserve directory structure
-      await $`bunx @swc/cli ${srcDir} -d ${config.build.outDir} -C jsc.parser.syntax=typescript -C jsc.parser.tsx=true -C jsc.target=es2020 -C module.type=es6 -C jsc.transform.react.runtime=automatic`
+      /*
+       * Tests do not ship.
+       *
+       * swc transpiled the whole directory, tests included, so sixteen `.test.js`
+       * files went out in the published package — dead weight for every consumer,
+       * and a live hazard here: `bun test <path>` matches by substring, so
+       * `bun test fe/...` also collected `dist/fe/...` and ran the COMPILED
+       * copies. A test that reads a source file by relative path then failed
+       * from dist, where that path does not exist — a red run caused entirely by
+       * a stale build artefact of a test that passes.
+       */
+      await $`bunx @swc/cli ${srcDir} -d ${config.build.outDir} --ignore ${'**/*.test.ts'} --ignore ${'**/*.test.tsx'} -C jsc.parser.syntax=typescript -C jsc.parser.tsx=true -C jsc.target=es2020 -C module.type=es6 -C jsc.transform.react.runtime=automatic`
         .quiet()
         .catch((e) => {
           log.warn(`swc warning: ${e}`)
@@ -146,7 +156,7 @@ async function transpileClientModules() {
   const transpileDirs = config.transpileDirs || []
   for (const srcDir of transpileDirs) {
     log.info(`  Transpiling dependency: ${srcDir}`)
-    await $`bunx @swc/cli ${srcDir} -d ${config.build.outDir} -C jsc.parser.syntax=typescript -C jsc.parser.tsx=true -C jsc.target=es2020 -C module.type=es6 -C jsc.transform.react.runtime=automatic`
+    await $`bunx @swc/cli ${srcDir} -d ${config.build.outDir} --ignore ${'**/*.test.ts'} --ignore ${'**/*.test.tsx'} -C jsc.parser.syntax=typescript -C jsc.parser.tsx=true -C jsc.target=es2020 -C module.type=es6 -C jsc.transform.react.runtime=automatic`
       .quiet()
       .catch((e) => {
         log.warn(`swc warning: ${e}`)
@@ -185,6 +195,63 @@ async function generateTypes() {
   log.success('Type definitions generated (core src/ verified clean)')
 }
 
+/**
+ * What the package must and must not contain, checked before it can be published.
+ *
+ * Both halves of this were live mistakes on the same afternoon. Tests shipped
+ * for months — sixteen `.test.js` files in every consumer's node_modules, and
+ * a trap here too, because `bun test <path>` matches by substring and so ran
+ * the COMPILED copies out of `dist`. Then excluding them with an unquoted glob
+ * silently took `src/Shared/cron.js` with it: the build still said OK, the
+ * declarations were still there, and the missing file would have broken the
+ * CONSUMER's build rather than ours — the config file next to it warns about
+ * exactly that failure.
+ *
+ * So the shape of the package is asserted, not assumed. A build that cannot
+ * satisfy this refuses to finish, which is the only moment the cost is still
+ * ours.
+ */
+async function verifyPackageShape() {
+  log.info('Verifying what the package contains...')
+
+  /*
+   * Walked here rather than through `getJsFiles`, which filters out everything
+   * the obfuscator is told to skip — `fe/` among them. That is the right list
+   * for obfuscation and the wrong one for this: the sixteen test files this
+   * check exists to catch were all under `dist/fe`, and a check that cannot see
+   * them would have passed while they shipped.
+   */
+  const shipped: string[] = []
+  const walk = async (dir: string) => {
+    for (const entry of await readdir(dir, { withFileTypes: true })) {
+      const full = join(dir, entry.name)
+      if (entry.isDirectory()) await walk(full)
+      else if (entry.name.endsWith('.js')) shipped.push(full)
+    }
+  }
+  await walk(config.build.outDir)
+
+  const tests = shipped.filter((file) => /\.test\.js$/.test(file))
+  if (tests.length > 0) {
+    log.error(`${tests.length} test file(s) would be published, e.g. ${tests[0]}`)
+    throw new Error('tests must not ship in the package')
+  }
+
+  // Every directory shipped for the frontend to import at runtime has to have
+  // actually produced something. An empty one is a file the consumer asks for
+  // and never receives.
+  for (const srcDir of config.transpileDirs || []) {
+    const outDir = join(config.build.outDir, srcDir.replace('./', ''))
+    const produced = shipped.filter((file) => file.includes(outDir))
+    if (produced.length === 0) {
+      log.error(`${srcDir} produced no JavaScript in ${outDir}`)
+      throw new Error(`${srcDir} is declared shippable but nothing was emitted for it`)
+    }
+  }
+
+  log.success(`Package shape verified (${shipped.length} files, no tests)`)
+}
+
 async function getJsFiles(dir: string): Promise<string[]> {
   const files: string[] = []
 
@@ -346,6 +413,7 @@ async function main() {
 
     log.step(7, 7, 'Verifying...')
     await verifyBuild()
+    await verifyPackageShape()
 
     const elapsed = ((Date.now() - startTime) / 1000).toFixed(2)
     console.log(`\n${GREEN}🎉 Build completed in ${elapsed}s${NC}\n`)

package/dist/fe/components/IntegrationsPage/components/RunPlanIssues.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/fe/components/IntegrationsPage/components/RunPlanIssues.test.js

@@ -1,44 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { describeRow } from './RunPlanIssues';
-/**
- * A preview that names the key which collided but not the values behind it
- * cannot answer the only question worth asking: is this the same record listed
- * twice, or two records the key cannot tell apart? The first is a skip; the
- * second means the key is too narrow and rows are being lost.
- */ describe('describeRow', ()=>{
-    test('lists the mapped columns and their values, in order', ()=>{
-        expect(describeRow({
-            name: 'ÜRETİM PLANLAMA MÜDÜRLÜĞÜ',
-            slug: 'TAT-110'
-        })).toBe('name: ÜRETİM PLANLAMA MÜDÜRLÜĞÜ, slug: TAT-110');
-    });
-    test('an empty column reads as a dash, not as nothing at all', ()=>{
-        expect(describeRow({
-            name: null,
-            slug: 'TAT-110'
-        })).toBe('name: —, slug: TAT-110');
-        expect(describeRow({
-            name: undefined,
-            slug: 'X'
-        })).toBe('name: —, slug: X');
-    });
-    test('a long value is cut rather than allowed to bury the rest', ()=>{
-        const long = 'A'.repeat(200);
-        const described = describeRow({
-            description: long,
-            slug: 'X'
-        });
-        expect(described.length).toBeLessThan(120);
-        expect(described).toContain('…');
-        expect(described).toContain('slug: X');
-    });
-    test('non-string values are shown rather than dropped', ()=>{
-        expect(describeRow({
-            displayOrder: 0,
-            enabled: false
-        })).toBe('displayOrder: 0, enabled: false');
-    });
-    test('an empty row yields an empty description rather than punctuation', ()=>{
-        expect(describeRow({})).toBe('');
-    });
-});

package/dist/fe/components/IntegrationsPage/components/RunPlanSuggestions.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/fe/components/IntegrationsPage/components/RunPlanSuggestions.test.js

@@ -1,103 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import { missingRequiredCounts, suggestEmailTemplate } from './RunPlanSuggestions';
-/**
- * A preview that says "561 records are missing e-mail" has told the truth and
- * stopped one step short of being useful. The answer is nearly always to build
- * the value from the fields that ARE there, and the panel knows which those are.
- */ const plan = (issues)=>({
-        issues,
-        referenceInserts: [],
-        warnings: []
-    });
-const issue = (message, i)=>({
-        sourceIndex: i,
-        kind: 'missing_required',
-        message
-    });
-describe('counting what each missing field costs', ()=>{
-    it('counts the records one field kept out', ()=>{
-        const counts = missingRequiredCounts(plan([
-            issue('Required field(s) empty: email', 0),
-            issue('Required field(s) empty: email', 1)
-        ]));
-        expect(counts).toEqual([
-            {
-                field: 'email',
-                records: 2
-            }
-        ]);
-    });
-    it('counts each field of a record that is missing two', ()=>{
-        const counts = missingRequiredCounts(plan([
-            issue('Required field(s) empty: email, code', 0)
-        ]));
-        expect(counts).toEqual([
-            {
-                field: 'email',
-                records: 1
-            },
-            {
-                field: 'code',
-                records: 1
-            }
-        ]);
-    });
-    it('puts the biggest problem first', ()=>{
-        const counts = missingRequiredCounts(plan([
-            issue('Required field(s) empty: code', 0),
-            issue('Required field(s) empty: email', 1),
-            issue('Required field(s) empty: email', 2)
-        ]));
-        expect(counts[0]).toEqual({
-            field: 'email',
-            records: 2
-        });
-    });
-    it('ignores issues of every other kind', ()=>{
-        const counts = missingRequiredCounts(plan([
-            {
-                sourceIndex: 0,
-                kind: 'duplicate_in_batch',
-                message: 'twice'
-            }
-        ]));
-        expect(counts).toEqual([]);
-    });
-});
-describe('the address it suggests building', ()=>{
-    const mapping = (sources)=>({
-            fieldMappings: sources.map((source)=>({
-                    source,
-                    target: source
-                }))
-        });
-    it('is built from the fields this source really sends', ()=>{
-        expect(suggestEmailTemplate(mapping([
-            'name',
-            'surname',
-            'employeeNo'
-        ]))).toBe('{name}.{surname}@example.com');
-    });
-    it('recognises the other names those fields go by', ()=>{
-        expect(suggestEmailTemplate(mapping([
-            'firstName',
-            'lastName'
-        ]))).toBe('{firstName}.{lastName}@example.com');
-    });
-    it('offers what it can when only one of the two is there', ()=>{
-        expect(suggestEmailTemplate(mapping([
-            'surname'
-        ]))).toBe('{surname}@example.com');
-    });
-    it('suggests nothing rather than nonsense when there is no name at all', ()=>{
-        expect(suggestEmailTemplate(mapping([
-            'employeeNo',
-            'departmentCode'
-        ]))).toBeNull();
-    });
-    it('ignores a source that is already a template', ()=>{
-        expect(suggestEmailTemplate(mapping([
-            '{a}-{b}'
-        ]))).toBeNull();
-    });
-});

package/dist/fe/components/IntegrationsPage/components/connectionDraft.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/fe/components/IntegrationsPage/components/connectionDraft.test.js

@@ -1,198 +0,0 @@
-import { describe, expect, it, test } from 'bun:test';
-import { draftFromSource, draftPatchFromSource, draftToSource, emptyConnectionDraft, validateConnectionDraft } from './connectionDraft';
-/**
- * Found in production, creating the first connection: the form said "Empty
- * means the server default" under the timeout, and saving with it empty
- * answered "Missing required field: timeout_ms".
- *
- * `timeout_ms` is NOT NULL with a default of 30000. An explicit null does not
- * fall back to a column default — it overrides it and violates the constraint.
- * The distinction between "send null" and "do not send the key" is the whole
- * bug, so it is what these assert.
- */ const filled = ()=>({
-        ...emptyConnectionDraft,
-        name: 'TatMetal HR',
-        slug: 'tatmetal-hr',
-        baseUrl: 'https://online.tatmetal.com/hr-service'
-    });
-describe('draftToSource — columns that are NOT NULL with a default', ()=>{
-    test('an empty timeout is omitted, not sent as null', ()=>{
-        const payload = draftToSource(filled());
-        expect('timeoutMs' in payload).toBe(false);
-        expect(payload.timeoutMs).toBeUndefined();
-    });
-    test('a timeout that was typed is sent as a number', ()=>{
-        const payload = draftToSource({
-            ...filled(),
-            timeoutMs: '45000'
-        });
-        expect(payload.timeoutMs).toBe(45000);
-    });
-    test('whitespace and nonsense are treated as empty rather than as null', ()=>{
-        for (const value of [
-            '   ',
-            'abc',
-            '0',
-            '-1'
-        ]){
-            const payload = draftToSource({
-                ...filled(),
-                timeoutMs: value
-            });
-            expect(`${value} → ${'timeoutMs' in payload}`).toBe(`${value} → false`);
-        }
-    });
-    test('the other NOT NULL columns always carry a concrete value', ()=>{
-        const payload = draftToSource(filled());
-        expect(payload.authType).toBe('none');
-        expect(payload.tlsVerify).toBe(true);
-        expect(payload.enabled).toBe(true);
-    });
-});
-describe('draftToSource — fields the chosen auth type does not use', ()=>{
-    test('a bearer connection clears the OAuth settings rather than leaving them', ()=>{
-        const payload = draftToSource({
-            ...filled(),
-            authType: 'bearer',
-            tokenUrl: 'https://example.com/token',
-            oauthClientId: 'left-behind'
-        });
-        expect(payload.tokenUrl).toBeNull();
-        expect(payload.oauthClientId).toBeNull();
-        expect(payload.oauthGrantType).toBeNull();
-    });
-    test('a username is kept only for the password grant', ()=>{
-        const base = {
-            ...filled(),
-            authType: 'oauth2',
-            oauthUsername: 'svc-account'
-        };
-        expect(draftToSource({
-            ...base,
-            oauthGrantType: 'password'
-        }).oauthUsername).toBe('svc-account');
-        expect(draftToSource({
-            ...base,
-            oauthGrantType: 'client_credentials'
-        }).oauthUsername).toBeNull();
-    });
-});
-describe('validateConnectionDraft', ()=>{
-    test('the three fields a connection cannot do without are required', ()=>{
-        const errors = validateConnectionDraft(emptyConnectionDraft);
-        expect(errors.name).toBeDefined();
-        expect(errors.slug).toBeDefined();
-        expect(errors.baseUrl).toBeDefined();
-    });
-    test('a filled draft passes', ()=>{
-        expect(validateConnectionDraft(filled())).toEqual({});
-    });
-    test('plain http is accepted — an in-cluster service is a normal target', ()=>{
-        const errors = validateConnectionDraft({
-            ...filled(),
-            baseUrl: 'http://hr-service:8080'
-        });
-        expect(errors.baseUrl).toBeUndefined();
-    });
-    test('a non-numeric timeout is refused before it can reach the server', ()=>{
-        expect(validateConnectionDraft({
-            ...filled(),
-            timeoutMs: 'soon'
-        }).timeoutMs).toBeDefined();
-        expect(validateConnectionDraft({
-            ...filled(),
-            timeoutMs: ''
-        }).timeoutMs).toBeUndefined();
-    });
-});
-describe('draftFromSource', ()=>{
-    test('a saved timeout comes back into the field', ()=>{
-        const draft = draftFromSource({
-            id: 'a',
-            name: 'n',
-            slug: 's',
-            baseUrl: 'https://x.test',
-            authType: 'none',
-            timeoutMs: 45000
-        });
-        expect(draft.timeoutMs).toBe('45000');
-    });
-    test('a round trip through the form does not invent a change', ()=>{
-        const source = {
-            id: 'a',
-            name: 'n',
-            slug: 's',
-            baseUrl: 'https://x.test',
-            authType: 'none',
-            tlsVerify: true,
-            enabled: true,
-            timeoutMs: 30000
-        };
-        expect(draftToSource(draftFromSource(source), 'a').timeoutMs).toBe(30000);
-    });
-});
-/**
- * What a save is allowed to correct in the boxes.
- *
- * After an edit the form showed what was TYPED, not what was stored: emptying
- * the timeout left the box empty while the connection kept timing out at the
- * stored value, and a trailing space in the name was trimmed on the way out so
- * the switcher above and the box below disagreed until F5. The reply has to be
- * read back — but only the parts of it that are actually there, because a
- * field-scoped patch claim strips columns out, and `draftFromSource` fills a
- * default for every column it does not find. Blanking a required box is worse
- * than leaving it stale.
- */ describe('the boxes a saved record corrects', ()=>{
-    const stored = {
-        id: 's1',
-        name: 'Acme',
-        slug: 'acme',
-        baseUrl: 'https://acme.test',
-        timeoutMs: 30000
-    };
-    it('takes the server’s value for a field it answered with', ()=>{
-        // Typed "Acme " with a trailing space; stored trimmed.
-        expect(draftPatchFromSource(stored).name).toBe('Acme');
-    });
-    /** The case this exists for: the box says empty, the server says 30000. */ it('corrects a timeout the server kept when the box was emptied', ()=>{
-        expect(draftPatchFromSource(stored).timeoutMs).toBe('30000');
-    });
-    it('says nothing at all about a field the reply left out', ()=>{
-        const patch = draftPatchFromSource({
-            id: 's1',
-            name: 'Acme'
-        });
-        expect(patch).toEqual({
-            name: 'Acme'
-        });
-        expect('slug' in patch).toBe(false);
-        expect('timeoutMs' in patch).toBe(false);
-    });
-    /**
-   * The failure this shape prevents: applied over a real draft, a partial reply
-   * must correct what it mentions and leave everything else alone.
-   */ it('leaves the rest of the draft untouched when applied over it', ()=>{
-        const draft = {
-            ...emptyConnectionDraft,
-            name: 'Acme ',
-            slug: 'acme',
-            baseUrl: 'https://a.test'
-        };
-        const next = {
-            ...draft,
-            ...draftPatchFromSource({
-                id: 's1',
-                name: 'Acme'
-            })
-        };
-        expect(next.name).toBe('Acme');
-        expect(next.slug).toBe('acme');
-        expect(next.baseUrl).toBe('https://a.test');
-    });
-    /** null is an answer — "no timeout" — not an absence. */ it('treats a null the server returned as a value, not as silence', ()=>{
-        expect(draftPatchFromSource({
-            id: 's1',
-            timeoutMs: null
-        }).timeoutMs).toBe('');
-    });
-});

package/dist/fe/components/IntegrationsPage/components/credentialSlots.contract.test.d.ts

@@ -1 +0,0 @@
-export {};