@omnifyjp/ts 5.2.2 → 5.3.0

package/dist/cli.js

@@ -28,7 +28,8 @@ import { resolve, dirname, join } from 'node:path';
 import { Command } from 'commander';
 import { parse as parseYaml } from 'yaml';
 import { generateTypeScript } from './generator.js';
-import { generatePhp } from './php/index.js';
+import { generatePhp, derivePhpConfig } from './php/index.js';
+import { pruneOrphanServiceFiles } from './php/orphan-cleanup.js';
 import { resolveInput, sniffInputKind } from './input-resolver.js';
 function resolveFromConfig(configPath) {
     const raw = readFileSync(configPath, 'utf-8');
@@ -238,6 +239,25 @@ program
             console.log(`  ${phpCreated} files created (user-editable)`);
         if (phpSkipped > 0)
             console.log(`  ${phpSkipped} files skipped (already exist)`);
+        // Orphan cleanup: when a schema is removed, renamed, flipped from
+        // kind:object → kind:pivot, or opted out via `options.service: false`,
+        // its previously-emitted `*ServiceBase.php` becomes orphan and
+        // pollutes Composer autoload. Prune base files automatically; warn
+        // about editable `*Service.php` (may contain user code).
+        const phpConfig = derivePhpConfig(laravelOverrides);
+        const cleanup = pruneOrphanServiceFiles(configDir, phpConfig, phpFiles);
+        if (cleanup.prunedBases.length > 0) {
+            console.log(`  ${cleanup.prunedBases.length} orphan ServiceBase pruned (schema removed/renamed/opted-out)`);
+            for (const p of cleanup.prunedBases) {
+                console.log(`    pruned: ${p}`);
+            }
+        }
+        for (const p of cleanup.warnedEditables) {
+            console.warn(`[omnify-ts] orphan editable service ${p} — backing schema is no ` +
+                `longer eligible for service codegen (removed / renamed / opted out / ` +
+                `flipped to non-object kind). Safe to delete by hand if it has no ` +
+                `custom code inside; preserved for now to protect any hand-edits.`);
+        }
     }
     console.log(`\nGeneration complete.`);
 });

package/dist/php/orphan-cleanup.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Orphan cleanup for service codegen.
+ *
+ * Service generation is opt-out (#81): every project `kind: object` schema
+ * gets a `<Name>ServiceBase.php` (regenerated wholesale, no user content)
+ * and a `<Name>Service.php` (sinh-1-lần userFile, may contain hand code).
+ *
+ * When a schema flips from `kind: object` → `kind: pivot`, gets renamed,
+ * removed, opted out via `options.service: false`, or hidden, the
+ * previously-emitted base service stays on disk forever and pollutes
+ * Composer autoload (a class file with no backing schema = mystery code
+ * for the next dev to inherit).
+ *
+ * This module mirrors the existing pivot YAML cleanup pattern
+ * (`RemoveOrphanAutoPivots` in the Go layer): scan known service
+ * directories, diff against the current generation's expected output set,
+ * delete the orphan base files. Editable `*Service.php` files are NEVER
+ * deleted — they may contain hand-written user code — instead a console
+ * warning is printed so the user can decide whether to clean up by hand.
+ */
+import type { GeneratedFile, PhpConfig } from './types.js';
+export interface ServiceCleanupResult {
+    /** Absolute paths to `*ServiceBase.php` files that were deleted. */
+    prunedBases: string[];
+    /** Absolute paths to `*Service.php` files that look orphan but are
+     *  preserved (may contain user code). Caller should print a warning. */
+    warnedEditables: string[];
+}
+/**
+ * Delete orphan `*ServiceBase.php` files; flag orphan editable services
+ * for warning. Pure-ish: takes the generated file list (= source of
+ * truth for "what should exist") and the resolved PhpConfig (= where to
+ * look). Filesystem mutations are limited to `unlinkSync` on base files
+ * that are demonstrably absent from the generated set.
+ */
+export declare function pruneOrphanServiceFiles(configDir: string, config: PhpConfig, generated: readonly GeneratedFile[]): ServiceCleanupResult;

package/dist/php/orphan-cleanup.js

@@ -0,0 +1,124 @@
+/**
+ * Orphan cleanup for service codegen.
+ *
+ * Service generation is opt-out (#81): every project `kind: object` schema
+ * gets a `<Name>ServiceBase.php` (regenerated wholesale, no user content)
+ * and a `<Name>Service.php` (sinh-1-lần userFile, may contain hand code).
+ *
+ * When a schema flips from `kind: object` → `kind: pivot`, gets renamed,
+ * removed, opted out via `options.service: false`, or hidden, the
+ * previously-emitted base service stays on disk forever and pollutes
+ * Composer autoload (a class file with no backing schema = mystery code
+ * for the next dev to inherit).
+ *
+ * This module mirrors the existing pivot YAML cleanup pattern
+ * (`RemoveOrphanAutoPivots` in the Go layer): scan known service
+ * directories, diff against the current generation's expected output set,
+ * delete the orphan base files. Editable `*Service.php` files are NEVER
+ * deleted — they may contain hand-written user code — instead a console
+ * warning is printed so the user can decide whether to clean up by hand.
+ */
+import { existsSync, readdirSync, statSync, unlinkSync } from 'node:fs';
+import { join, resolve, basename } from 'node:path';
+/**
+ * Delete orphan `*ServiceBase.php` files; flag orphan editable services
+ * for warning. Pure-ish: takes the generated file list (= source of
+ * truth for "what should exist") and the resolved PhpConfig (= where to
+ * look). Filesystem mutations are limited to `unlinkSync` on base files
+ * that are demonstrably absent from the generated set.
+ */
+export function pruneOrphanServiceFiles(configDir, config, generated) {
+    // Build the absolute-path set of files THIS generation pass produced.
+    // Anything matching `*ServiceBase.php` outside this set is orphan.
+    const expectedAbs = new Set();
+    for (const f of generated) {
+        expectedAbs.add(resolve(configDir, f.path));
+    }
+    const result = { prunedBases: [], warnedEditables: [] };
+    // ---- Base service cleanup -----------------------------------------------
+    //
+    // Search roots cover both layout modes:
+    //   - Modular: `<modules.path>/<Schema>/Services/<Schema>ServiceBase.php`
+    //     (one folder per schema; orphan schemas have orphan folders)
+    //   - Legacy: `<services.basePath>/<Schema>ServiceBase.php`
+    //     (flat folder; orphan schemas leave loose files)
+    //
+    // We always scan BOTH so a project that switched modes mid-flight gets
+    // the leftover-from-the-other-mode files cleaned too.
+    const baseSearchRoots = [];
+    if (config.structure === 'modular') {
+        const modulesAbs = resolve(configDir, config.modules.path);
+        if (existsSync(modulesAbs) && statSync(modulesAbs).isDirectory()) {
+            for (const entry of readdirSync(modulesAbs)) {
+                const svcDir = join(modulesAbs, entry, 'Services');
+                if (existsSync(svcDir) && statSync(svcDir).isDirectory()) {
+                    baseSearchRoots.push(svcDir);
+                }
+            }
+        }
+    }
+    baseSearchRoots.push(resolve(configDir, config.services.basePath));
+    for (const root of baseSearchRoots) {
+        if (!existsSync(root))
+            continue;
+        for (const entry of readdirSync(root)) {
+            if (!entry.endsWith('ServiceBase.php'))
+                continue;
+            const fullPath = join(root, entry);
+            if (expectedAbs.has(fullPath))
+                continue;
+            try {
+                unlinkSync(fullPath);
+                result.prunedBases.push(fullPath);
+            }
+            catch {
+                // EPERM / EBUSY / ENOENT — skip. The next generate pass will
+                // retry; meanwhile we don't crash the whole codegen pipeline
+                // on a single uncleanable file.
+            }
+        }
+    }
+    // ---- Editable service warning -------------------------------------------
+    //
+    // Editable services live at `<services.path>/<Group>/<Schema>Service.php`
+    // (group-nested) or `<services.path>/<Schema>Service.php` (no group).
+    // The recursive walk skips the `OmnifyBase` subfolder (already covered
+    // by the base cleanup above) so we don't double-process or warn on
+    // base files masquerading as editable.
+    const editableRoot = resolve(configDir, config.services.path);
+    walkServiceFiles(editableRoot, (path) => {
+        const name = basename(path);
+        if (name.endsWith('ServiceBase.php'))
+            return;
+        if (!name.endsWith('Service.php'))
+            return;
+        if (expectedAbs.has(path))
+            return;
+        result.warnedEditables.push(path);
+    });
+    return result;
+}
+function walkServiceFiles(root, visit) {
+    if (!existsSync(root))
+        return;
+    for (const entry of readdirSync(root)) {
+        const full = join(root, entry);
+        let info;
+        try {
+            info = statSync(full);
+        }
+        catch {
+            continue;
+        }
+        if (info.isDirectory()) {
+            // OmnifyBase holds the base files we already process above —
+            // skip to avoid the editable scan re-flagging them.
+            if (entry === 'OmnifyBase')
+                continue;
+            walkServiceFiles(full, visit);
+        }
+        else {
+            visit(full);
+        }
+    }
+}

package/dist/php/service-generator.d.ts

@@ -27,3 +27,18 @@ import type { GeneratedFile, PhpConfig } from './types.js';
  *  - package-owned schemas (those get services in their owning package)
  */
 export declare function generateServices(reader: SchemaReader, config: PhpConfig): GeneratedFile[];
+/**
+ * Returns the set of `*ServiceBase.php` filenames the current schema set
+ * is expected to produce. The cli.ts orphan-cleanup compares this set
+ * against the actual files in the base-services directory and deletes
+ * any mismatches — handles the case where a schema is renamed, removed,
+ * flipped from `kind: object` to `kind: pivot`, or opted out via
+ * `options.service: false`.
+ *
+ * Filename format mirrors `generateBaseService`: `{PascalSchemaName}ServiceBase.php`.
+ *
+ * Editable `*Service.php` files are NOT in scope — those are user-owned
+ * (sinh-1-lần userFile semantics) and may contain hand-written code; the
+ * cli prints a warning instead of deleting them.
+ */
+export declare function expectedBaseServiceFileNames(reader: SchemaReader): Set<string>;

package/dist/php/service-generator.js

@@ -31,17 +31,40 @@ import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace
  */
 export function generateServices(reader, config) {
     const files = [];
+    const candidates = collectServiceCandidates(reader);
+    // Emit deprecation warnings once per schema for legacy service-block keys
+    // that now duplicate property-level metadata.
+    for (const [name, schema] of Object.entries(candidates)) {
+        warnLegacyServiceKeys(name, schema);
+    }
+    for (const [name, schema] of Object.entries(candidates)) {
+        files.push(...generateForSchema(name, schema, reader, config));
+    }
+    return files;
+}
+/**
+ * Collect the set of schemas that should produce a service (base + editable
+ * pair) on this generation pass. Shared by `generateServices` (which emits
+ * the files) and `expectedBaseServiceFileNames` (which drives the orphan
+ * cleanup in cli.ts). Keeping a single source of truth for the candidate
+ * filter means the cleanup can never disagree with the emitter — when a
+ * schema flips from `kind: object` to `kind: pivot`, the previously-emitted
+ * `*ServiceBase.php` becomes orphan and the cleanup deletes it on the next
+ * regeneration.
+ *
+ * #81 + #80 interaction (v3.23.1): iterate every project-owned schema
+ * directly instead of going through `getProjectObjectSchemas()`, which
+ * filters out KindPartial. Phantom-upstream extends (#80 self-reference
+ * fallback — e.g. `kind: extend, target: Product` with no upstream
+ * package loaded) are kept as KindPartial so downstream generators
+ * skip emitting tables for them, but their SERVICES still belong in
+ * the consumer project and must be generated here. Kind=object stays
+ * the opt-out default; Kind=partial/extend is included when the user
+ * has signalled service intent (legacy options.service block or any
+ * property-level service flag).
+ */
+function collectServiceCandidates(reader) {
     const candidates = {};
-    // #81 + #80 interaction (v3.23.1): iterate every project-owned schema
-    // directly instead of going through `getProjectObjectSchemas()`, which
-    // filters out KindPartial. Phantom-upstream extends (#80 self-reference
-    // fallback — e.g. `kind: extend, target: Product` with no upstream
-    // package loaded) are kept as KindPartial so downstream generators
-    // skip emitting tables for them, but their SERVICES still belong in
-    // the consumer project and must be generated here. Kind=object stays
-    // the opt-out default; Kind=partial/extend is included when the user
-    // has signalled service intent (legacy options.service block or any
-    // property-level service flag).
     const allSchemas = reader.getSchemas();
     for (const [name, schema] of Object.entries(allSchemas)) {
         // Project-owned only — packages emit their own services in the
@@ -89,15 +112,29 @@ export function generateServices(reader, config) {
             candidates[name] = schema;
         }
     }
-    // Emit deprecation warnings once per schema for legacy service-block keys
-    // that now duplicate property-level metadata.
-    for (const [name, schema] of Object.entries(candidates)) {
-        warnLegacyServiceKeys(name, schema);
-    }
-    for (const [name, schema] of Object.entries(candidates)) {
-        files.push(...generateForSchema(name, schema, reader, config));
+    return candidates;
+}
+/**
+ * Returns the set of `*ServiceBase.php` filenames the current schema set
+ * is expected to produce. The cli.ts orphan-cleanup compares this set
+ * against the actual files in the base-services directory and deletes
+ * any mismatches — handles the case where a schema is renamed, removed,
+ * flipped from `kind: object` to `kind: pivot`, or opted out via
+ * `options.service: false`.
+ *
+ * Filename format mirrors `generateBaseService`: `{PascalSchemaName}ServiceBase.php`.
+ *
+ * Editable `*Service.php` files are NOT in scope — those are user-owned
+ * (sinh-1-lần userFile semantics) and may contain hand-written code; the
+ * cli prints a warning instead of deleting them.
+ */
+export function expectedBaseServiceFileNames(reader) {
+    const candidates = collectServiceCandidates(reader);
+    const out = new Set();
+    for (const name of Object.keys(candidates)) {
+        out.add(`${toPascalCase(name)}ServiceBase.php`);
     }
-    return files;
+    return out;
 }
 /**
  * #81 + #80 (v3.23.1): detect "user wants a service for this schema" signal

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnifyjp/ts",
-  "version": "5.2.2",
+  "version": "5.3.0",
   "description": "TypeScript model type generator from Omnify schemas.json",
   "type": "module",
   "main": "dist/index.js",